1pub const COBIAERR_NoError: u32 = 0;
4pub const COBIAERR_CAPEOPENError: u32 = 1;
5pub const COBIAERR_UnknownError: u32 = 100;
6pub const COBIAERR_CriticalError: u32 = 101;
7pub const COBIAERR_OutOfMemory: u32 = 102;
8pub const COBIAERR_NullPointer: u32 = 103;
9pub const COBIAERR_InvalidArgument: u32 = 104;
10pub const COBIAERR_NoSuchInterface: u32 = 105;
11pub const COBIAERR_Denied: u32 = 106;
12pub const COBIAERR_NoSuchItem: u32 = 107;
13pub const COBIAERR_NotImplemented: u32 = 108;
14pub const COBIAERR_NoService: u32 = 109;
15pub const COBIAERR_UnexpectedNumberOfValues: u32 = 110;
16pub const COBIAERR_UnexpectedDataType: u32 = 111;
17pub const COBIAERR_PersistenceError: u32 = 112;
18pub const COBIAERR_PersistenceSavedWithNewerVersion: u32 = 113;
19pub const COBIAERR_DeniedBecauseOfElevation: u32 = 114;
20pub const COBIAERR_InvalidOperation: u32 = 115;
21pub const COBIAERR_InvalidTypeLibrary: u32 = 116;
22pub const COBIAERR_InvalidConcurrentAccess: u32 = 117;
23pub const COBIAERR_Registry_NotFound: u32 = 500;
24pub const COBIAERR_Registry_AccessDenied: u32 = 501;
25pub const COBIAERR_Registry_Corrupt: u32 = 502;
26pub const COBIAERR_Registry_InvalidValueType: u32 = 503;
27pub const COBIAERR_Registry_InvalidName: u32 = 504;
28pub const COBIAERR_Registry_InvalidValue: u32 = 505;
29pub const COBIAERR_Registry_CannotCreate: u32 = 506;
30pub const COBIAERR_Registry_InsufficientData: u32 = 507;
31pub const COBIAERR_Marshal_Error: u32 = 601;
32pub const COBIAERR_Marshal_ConnectionClosed: u32 = 602;
33pub const COBIAERR_Marshal_ConnectionTimedOut: u32 = 603;
34pub type wchar_t = ::std::os::raw::c_ushort;
35#[repr(C)]
36#[derive(Debug, Copy, Clone)]
37pub struct _GUID {
38 pub Data1: ::std::os::raw::c_ulong,
39 pub Data2: ::std::os::raw::c_ushort,
40 pub Data3: ::std::os::raw::c_ushort,
41 pub Data4: [u8; 8usize],
42}
43#[allow(clippy::unnecessary_operation, clippy::identity_op)]
44const _: () = {
45 ["Size of _GUID"][::std::mem::size_of::<_GUID>() - 16usize];
46 ["Alignment of _GUID"][::std::mem::align_of::<_GUID>() - 4usize];
47 ["Offset of field: _GUID::Data1"][::std::mem::offset_of!(_GUID, Data1) - 0usize];
48 ["Offset of field: _GUID::Data2"][::std::mem::offset_of!(_GUID, Data2) - 4usize];
49 ["Offset of field: _GUID::Data3"][::std::mem::offset_of!(_GUID, Data3) - 6usize];
50 ["Offset of field: _GUID::Data4"][::std::mem::offset_of!(_GUID, Data4) - 8usize];
51};
52pub type GUID = _GUID;
53#[repr(C)]
54#[derive(Debug, Copy, Clone)]
55pub struct HWND__ {
56 pub unused: i32,
57}
58#[allow(clippy::unnecessary_operation, clippy::identity_op)]
59const _: () = {
60 ["Size of HWND__"][::std::mem::size_of::<HWND__>() - 4usize];
61 ["Alignment of HWND__"][::std::mem::align_of::<HWND__>() - 4usize];
62 ["Offset of field: HWND__::unused"][::std::mem::offset_of!(HWND__, unused) - 0usize];
63};
64pub type HWND = *mut HWND__;
65pub type CapeWindowId = HWND;
66pub type COBIACHAR = wchar_t;
67pub type CapeResult = u32;
68pub type CapeReal = f64;
69pub type CapeInteger = i32;
70pub type CapeEnumeration = i32;
71pub type CapeCharacter = COBIACHAR;
72pub type CapeBoolean = u32;
73pub type CapeByte = u8;
74#[repr(C)]
75#[derive(Debug, Copy, Clone)]
76pub struct _CapeUUID {
77 pub data: [u8; 16usize],
78}
79#[allow(clippy::unnecessary_operation, clippy::identity_op)]
80const _: () = {
81 ["Size of _CapeUUID"][::std::mem::size_of::<_CapeUUID>() - 16usize];
82 ["Alignment of _CapeUUID"][::std::mem::align_of::<_CapeUUID>() - 1usize];
83 ["Offset of field: _CapeUUID::data"][::std::mem::offset_of!(_CapeUUID, data) - 0usize];
84};
85pub type CapeUUID = _CapeUUID;
86unsafe extern "C" {
87 pub fn CapeUUID_nullValue() -> CapeUUID;
88}
89unsafe extern "C" {
90 pub fn capeUUID_Equal(uuid1: *const CapeUUID, uuid2: *const CapeUUID) -> bool;
91}
92unsafe extern "C" {
93 pub fn capeUUID_isnull(uuid: *const CapeUUID) -> bool;
94}
95unsafe extern "C" {
96 pub fn capeUUID_Compare(
97 uuid1: *const CapeUUID,
98 uuid2: *const CapeUUID,
99 ) -> i32;
100}
101unsafe extern "C" {
102 pub fn capeUUID_parse(string: *const ::std::os::raw::c_char, uuid: *mut CapeUUID) -> bool;
103}
104unsafe extern "C" {
105 pub fn capeUUID_format(uuid: *const CapeUUID) -> *mut ::std::os::raw::c_char;
106}
107unsafe extern "C" {
108 pub fn capeUUID_parsew(string: *const wchar_t, uuid: *mut CapeUUID) -> bool;
109}
110unsafe extern "C" {
111 pub fn capeUUID_formatw(uuid: *const CapeUUID) -> *mut wchar_t;
112}
113unsafe extern "C" {
114 pub fn capeUUID_swapOrder(tgt: *mut u8);
115}
116unsafe extern "C" {
117 pub fn capeUUIDFromGUID(guid: *const GUID) -> CapeUUID;
118}
119unsafe extern "C" {
120 pub fn GUIDFromCapeUUID(guid: *const CapeUUID) -> GUID;
121}
122pub const eCapeRegistryValueType_CapeRegValString: eCapeRegistryValueType = 0;
123pub const eCapeRegistryValueType_CapeRegValInteger: eCapeRegistryValueType = 1;
124pub const eCapeRegistryValueType_CapeRegValUUID: eCapeRegistryValueType = 2;
125pub const eCapeRegistryValueType_CapeRegValEmpty: eCapeRegistryValueType = 3;
126#[doc = "! Registry value type\n*!\nThe supported types of registry values.\n\\sa ICapeRegistryKey::getValueType()\n*/"]
127pub type eCapeRegistryValueType = i32;
128#[doc = "! Registry value type\n*!\nThe supported types of registry values.\n\\sa ICapeRegistryKey::getValueType()\n*/"]
129pub use self::eCapeRegistryValueType as CapeRegistryValueType;
130pub const eCapePMCServiceType_PMCService_Inproc32: eCapePMCServiceType = 0;
131pub const eCapePMCServiceType_PMCService_Inproc64: eCapePMCServiceType = 1;
132pub const eCapePMCServiceType_PMCService_COM32: eCapePMCServiceType = 2;
133pub const eCapePMCServiceType_PMCService_COM64: eCapePMCServiceType = 3;
134pub const eCapePMCServiceType_PMCService_Remote: eCapePMCServiceType = 4;
135pub const eCapePMCServiceType_PMCService_Local: eCapePMCServiceType = 5;
136pub const eCapePMCServiceType_PMCService_COUNT: eCapePMCServiceType = 6;
137#[doc = "! Service provider types\n*!\nService type enumeration for PMC instantiation\n*/"]
138pub type eCapePMCServiceType = i32;
139#[doc = "! Service provider types\n*!\nService type enumeration for PMC instantiation\n*/"]
140pub use self::eCapePMCServiceType as CapePMCServiceType;
141#[doc = "!<Value contains string"]
142pub const eCapeValueType_CapeValueTypeString: eCapeValueType = 0;
143#[doc = "!<Value contains integer"]
144pub const eCapeValueType_CapeValueTypeInteger: eCapeValueType = 1;
145#[doc = "!<Value contains boolean"]
146pub const eCapeValueType_CapeValueTypeBoolean: eCapeValueType = 2;
147#[doc = "!<Value contains real (double precision)"]
148pub const eCapeValueType_CapeValueTypeReal: eCapeValueType = 3;
149#[doc = "!<No value"]
150pub const eCapeValueType_CapeValueTypeEmpty: eCapeValueType = 4;
151#[doc = "! CapeValue data types\n*!\nThe supported types of CapeValue values.\n*/"]
152pub type eCapeValueType = i32;
153#[doc = "! CapeValue data types\n*!\nThe supported types of CapeValue values.\n*/"]
154pub use self::eCapeValueType as CapeValueType;
155pub type CapeSize = u32;
156#[repr(C)]
157#[derive(Debug, Copy, Clone)]
158pub struct _ICobiaBase_VTable {
159 pub addReference: ::std::option::Option<unsafe extern "C" fn(me: *mut ::std::os::raw::c_void)>,
160 pub release: ::std::option::Option<unsafe extern "C" fn(me: *mut ::std::os::raw::c_void)>,
161}
162#[allow(clippy::unnecessary_operation, clippy::identity_op)]
163const _: () = {
164 ["Size of _ICobiaBase_VTable"][::std::mem::size_of::<_ICobiaBase_VTable>() - 16usize];
165 ["Alignment of _ICobiaBase_VTable"][::std::mem::align_of::<_ICobiaBase_VTable>() - 8usize];
166 ["Offset of field: _ICobiaBase_VTable::addReference"]
167 [::std::mem::offset_of!(_ICobiaBase_VTable, addReference) - 0usize];
168 ["Offset of field: _ICobiaBase_VTable::release"]
169 [::std::mem::offset_of!(_ICobiaBase_VTable, release) - 8usize];
170};
171pub type ICobiaBase_VTable = _ICobiaBase_VTable;
172#[repr(C)]
173#[derive(Debug, Copy, Clone)]
174pub struct ICobiaBase {
175 #[doc = "!<object pointer"]
176 pub me: *mut ::std::os::raw::c_void,
177 #[doc = "!<function pointer table"]
178 pub vTbl: *mut ICobiaBase_VTable,
179}
180#[allow(clippy::unnecessary_operation, clippy::identity_op)]
181const _: () = {
182 ["Size of ICobiaBase"][::std::mem::size_of::<ICobiaBase>() - 16usize];
183 ["Alignment of ICobiaBase"][::std::mem::align_of::<ICobiaBase>() - 8usize];
184 ["Offset of field: ICobiaBase::me"][::std::mem::offset_of!(ICobiaBase, me) - 0usize];
185 ["Offset of field: ICobiaBase::vTbl"][::std::mem::offset_of!(ICobiaBase, vTbl) - 8usize];
186};
187#[repr(C)]
188#[derive(Debug, Copy, Clone)]
189pub struct ICapeInterface_VTable {
190 pub addReference: ::std::option::Option<unsafe extern "C" fn(me: *mut ::std::os::raw::c_void)>,
191 pub release: ::std::option::Option<unsafe extern "C" fn(me: *mut ::std::os::raw::c_void)>,
192 pub queryInterface: ::std::option::Option<
193 unsafe extern "C" fn(
194 me: *mut ::std::os::raw::c_void,
195 uuid: *const CapeUUID,
196 ptr: *mut *mut _ICapeInterface,
197 ) -> CapeResult,
198 >,
199 pub getLastError: ::std::option::Option<
200 unsafe extern "C" fn(
201 me: *mut ::std::os::raw::c_void,
202 ptr: *mut *mut _ICapeError,
203 ) -> CapeResult,
204 >,
205}
206#[allow(clippy::unnecessary_operation, clippy::identity_op)]
207const _: () = {
208 ["Size of ICapeInterface_VTable"][::std::mem::size_of::<ICapeInterface_VTable>() - 32usize];
209 ["Alignment of ICapeInterface_VTable"]
210 [::std::mem::align_of::<ICapeInterface_VTable>() - 8usize];
211 ["Offset of field: ICapeInterface_VTable::addReference"]
212 [::std::mem::offset_of!(ICapeInterface_VTable, addReference) - 0usize];
213 ["Offset of field: ICapeInterface_VTable::release"]
214 [::std::mem::offset_of!(ICapeInterface_VTable, release) - 8usize];
215 ["Offset of field: ICapeInterface_VTable::queryInterface"]
216 [::std::mem::offset_of!(ICapeInterface_VTable, queryInterface) - 16usize];
217 ["Offset of field: ICapeInterface_VTable::getLastError"]
218 [::std::mem::offset_of!(ICapeInterface_VTable, getLastError) - 24usize];
219};
220#[repr(C)]
221#[derive(Debug, Copy, Clone)]
222pub struct _ICapeInterface {
223 pub me: *mut ::std::os::raw::c_void,
224 #[doc = "!<function pointer table"]
225 pub vTbl: *mut ICapeInterface_VTable,
226}
227#[allow(clippy::unnecessary_operation, clippy::identity_op)]
228const _: () = {
229 ["Size of _ICapeInterface"][::std::mem::size_of::<_ICapeInterface>() - 16usize];
230 ["Alignment of _ICapeInterface"][::std::mem::align_of::<_ICapeInterface>() - 8usize];
231 ["Offset of field: _ICapeInterface::me"][::std::mem::offset_of!(_ICapeInterface, me) - 0usize];
232 ["Offset of field: _ICapeInterface::vTbl"]
233 [::std::mem::offset_of!(_ICapeInterface, vTbl) - 8usize];
234};
235pub type ICapeInterface = _ICapeInterface;
236#[repr(C)]
237#[derive(Debug, Copy, Clone)]
238pub struct ICapeError_VTable {
239 pub base: ICobiaBase_VTable,
240 pub getErrorText: ::std::option::Option<
241 unsafe extern "C" fn(
242 me: *mut ::std::os::raw::c_void,
243 errorText: *mut _ICapeString,
244 ) -> CapeResult,
245 >,
246 pub getCause: ::std::option::Option<
247 unsafe extern "C" fn(
248 me: *mut ::std::os::raw::c_void,
249 cause: *mut *mut _ICapeError,
250 ) -> CapeResult,
251 >,
252 pub getSource: ::std::option::Option<
253 unsafe extern "C" fn(
254 me: *mut ::std::os::raw::c_void,
255 componentDescription: *mut _ICapeString,
256 ) -> CapeResult,
257 >,
258 pub getScope: ::std::option::Option<
259 unsafe extern "C" fn(
260 me: *mut ::std::os::raw::c_void,
261 errorScope: *mut _ICapeString,
262 ) -> CapeResult,
263 >,
264}
265#[allow(clippy::unnecessary_operation, clippy::identity_op)]
266const _: () = {
267 ["Size of ICapeError_VTable"][::std::mem::size_of::<ICapeError_VTable>() - 48usize];
268 ["Alignment of ICapeError_VTable"][::std::mem::align_of::<ICapeError_VTable>() - 8usize];
269 ["Offset of field: ICapeError_VTable::base"]
270 [::std::mem::offset_of!(ICapeError_VTable, base) - 0usize];
271 ["Offset of field: ICapeError_VTable::getErrorText"]
272 [::std::mem::offset_of!(ICapeError_VTable, getErrorText) - 16usize];
273 ["Offset of field: ICapeError_VTable::getCause"]
274 [::std::mem::offset_of!(ICapeError_VTable, getCause) - 24usize];
275 ["Offset of field: ICapeError_VTable::getSource"]
276 [::std::mem::offset_of!(ICapeError_VTable, getSource) - 32usize];
277 ["Offset of field: ICapeError_VTable::getScope"]
278 [::std::mem::offset_of!(ICapeError_VTable, getScope) - 40usize];
279};
280#[repr(C)]
281#[derive(Debug, Copy, Clone)]
282pub struct _ICapeError {
283 pub me: *mut ::std::os::raw::c_void,
284 #[doc = "!<function pointer table"]
285 pub vTbl: *mut ICapeError_VTable,
286}
287#[allow(clippy::unnecessary_operation, clippy::identity_op)]
288const _: () = {
289 ["Size of _ICapeError"][::std::mem::size_of::<_ICapeError>() - 16usize];
290 ["Alignment of _ICapeError"][::std::mem::align_of::<_ICapeError>() - 8usize];
291 ["Offset of field: _ICapeError::me"][::std::mem::offset_of!(_ICapeError, me) - 0usize];
292 ["Offset of field: _ICapeError::vTbl"][::std::mem::offset_of!(_ICapeError, vTbl) - 8usize];
293};
294pub type ICapeError = _ICapeError;
295#[repr(C)]
296#[derive(Debug, Copy, Clone)]
297pub struct ICapeArrayReal_VTable {
298 pub get: ::std::option::Option<
299 unsafe extern "C" fn(
300 me: *mut ::std::os::raw::c_void,
301 data: *mut *mut CapeReal,
302 size: *mut CapeSize,
303 ),
304 >,
305 pub setsize: ::std::option::Option<
306 unsafe extern "C" fn(
307 me: *mut ::std::os::raw::c_void,
308 size: CapeSize,
309 data: *mut *mut CapeReal,
310 ) -> CapeResult,
311 >,
312}
313#[allow(clippy::unnecessary_operation, clippy::identity_op)]
314const _: () = {
315 ["Size of ICapeArrayReal_VTable"][::std::mem::size_of::<ICapeArrayReal_VTable>() - 16usize];
316 ["Alignment of ICapeArrayReal_VTable"]
317 [::std::mem::align_of::<ICapeArrayReal_VTable>() - 8usize];
318 ["Offset of field: ICapeArrayReal_VTable::get"]
319 [::std::mem::offset_of!(ICapeArrayReal_VTable, get) - 0usize];
320 ["Offset of field: ICapeArrayReal_VTable::setsize"]
321 [::std::mem::offset_of!(ICapeArrayReal_VTable, setsize) - 8usize];
322};
323#[repr(C)]
324#[derive(Debug, Copy, Clone)]
325pub struct ICapeArrayReal {
326 pub me: *mut ::std::os::raw::c_void,
327 #[doc = "!<function pointer table"]
328 pub vTbl: *mut ICapeArrayReal_VTable,
329}
330#[allow(clippy::unnecessary_operation, clippy::identity_op)]
331const _: () = {
332 ["Size of ICapeArrayReal"][::std::mem::size_of::<ICapeArrayReal>() - 16usize];
333 ["Alignment of ICapeArrayReal"][::std::mem::align_of::<ICapeArrayReal>() - 8usize];
334 ["Offset of field: ICapeArrayReal::me"][::std::mem::offset_of!(ICapeArrayReal, me) - 0usize];
335 ["Offset of field: ICapeArrayReal::vTbl"]
336 [::std::mem::offset_of!(ICapeArrayReal, vTbl) - 8usize];
337};
338#[repr(C)]
339#[derive(Debug, Copy, Clone)]
340pub struct ICapeArrayInteger_VTable {
341 pub get: ::std::option::Option<
342 unsafe extern "C" fn(
343 me: *mut ::std::os::raw::c_void,
344 data: *mut *mut CapeInteger,
345 size: *mut CapeSize,
346 ),
347 >,
348 pub setsize: ::std::option::Option<
349 unsafe extern "C" fn(
350 me: *mut ::std::os::raw::c_void,
351 size: CapeSize,
352 data: *mut *mut CapeInteger,
353 ) -> CapeResult,
354 >,
355}
356#[allow(clippy::unnecessary_operation, clippy::identity_op)]
357const _: () = {
358 ["Size of ICapeArrayInteger_VTable"]
359 [::std::mem::size_of::<ICapeArrayInteger_VTable>() - 16usize];
360 ["Alignment of ICapeArrayInteger_VTable"]
361 [::std::mem::align_of::<ICapeArrayInteger_VTable>() - 8usize];
362 ["Offset of field: ICapeArrayInteger_VTable::get"]
363 [::std::mem::offset_of!(ICapeArrayInteger_VTable, get) - 0usize];
364 ["Offset of field: ICapeArrayInteger_VTable::setsize"]
365 [::std::mem::offset_of!(ICapeArrayInteger_VTable, setsize) - 8usize];
366};
367#[repr(C)]
368#[derive(Debug, Copy, Clone)]
369pub struct ICapeArrayInteger {
370 pub me: *mut ::std::os::raw::c_void,
371 #[doc = "!<function pointer table"]
372 pub vTbl: *mut ICapeArrayInteger_VTable,
373}
374#[allow(clippy::unnecessary_operation, clippy::identity_op)]
375const _: () = {
376 ["Size of ICapeArrayInteger"][::std::mem::size_of::<ICapeArrayInteger>() - 16usize];
377 ["Alignment of ICapeArrayInteger"][::std::mem::align_of::<ICapeArrayInteger>() - 8usize];
378 ["Offset of field: ICapeArrayInteger::me"]
379 [::std::mem::offset_of!(ICapeArrayInteger, me) - 0usize];
380 ["Offset of field: ICapeArrayInteger::vTbl"]
381 [::std::mem::offset_of!(ICapeArrayInteger, vTbl) - 8usize];
382};
383#[repr(C)]
384#[derive(Debug, Copy, Clone)]
385pub struct ICapeArrayByte_VTable {
386 pub get: ::std::option::Option<
387 unsafe extern "C" fn(
388 me: *mut ::std::os::raw::c_void,
389 data: *mut *mut CapeByte,
390 size: *mut CapeSize,
391 ),
392 >,
393 pub setsize: ::std::option::Option<
394 unsafe extern "C" fn(
395 me: *mut ::std::os::raw::c_void,
396 size: CapeSize,
397 data: *mut *mut CapeByte,
398 ) -> CapeResult,
399 >,
400}
401#[allow(clippy::unnecessary_operation, clippy::identity_op)]
402const _: () = {
403 ["Size of ICapeArrayByte_VTable"][::std::mem::size_of::<ICapeArrayByte_VTable>() - 16usize];
404 ["Alignment of ICapeArrayByte_VTable"]
405 [::std::mem::align_of::<ICapeArrayByte_VTable>() - 8usize];
406 ["Offset of field: ICapeArrayByte_VTable::get"]
407 [::std::mem::offset_of!(ICapeArrayByte_VTable, get) - 0usize];
408 ["Offset of field: ICapeArrayByte_VTable::setsize"]
409 [::std::mem::offset_of!(ICapeArrayByte_VTable, setsize) - 8usize];
410};
411#[repr(C)]
412#[derive(Debug, Copy, Clone)]
413pub struct ICapeArrayByte {
414 pub me: *mut ::std::os::raw::c_void,
415 #[doc = "!<function pointer table"]
416 pub vTbl: *mut ICapeArrayByte_VTable,
417}
418#[allow(clippy::unnecessary_operation, clippy::identity_op)]
419const _: () = {
420 ["Size of ICapeArrayByte"][::std::mem::size_of::<ICapeArrayByte>() - 16usize];
421 ["Alignment of ICapeArrayByte"][::std::mem::align_of::<ICapeArrayByte>() - 8usize];
422 ["Offset of field: ICapeArrayByte::me"][::std::mem::offset_of!(ICapeArrayByte, me) - 0usize];
423 ["Offset of field: ICapeArrayByte::vTbl"]
424 [::std::mem::offset_of!(ICapeArrayByte, vTbl) - 8usize];
425};
426#[repr(C)]
427#[derive(Debug, Copy, Clone)]
428pub struct ICapeArrayBoolean_VTable {
429 pub get: ::std::option::Option<
430 unsafe extern "C" fn(
431 me: *mut ::std::os::raw::c_void,
432 data: *mut *mut CapeBoolean,
433 size: *mut CapeSize,
434 ),
435 >,
436 pub setsize: ::std::option::Option<
437 unsafe extern "C" fn(
438 me: *mut ::std::os::raw::c_void,
439 size: CapeSize,
440 data: *mut *mut CapeBoolean,
441 ) -> CapeResult,
442 >,
443}
444#[allow(clippy::unnecessary_operation, clippy::identity_op)]
445const _: () = {
446 ["Size of ICapeArrayBoolean_VTable"]
447 [::std::mem::size_of::<ICapeArrayBoolean_VTable>() - 16usize];
448 ["Alignment of ICapeArrayBoolean_VTable"]
449 [::std::mem::align_of::<ICapeArrayBoolean_VTable>() - 8usize];
450 ["Offset of field: ICapeArrayBoolean_VTable::get"]
451 [::std::mem::offset_of!(ICapeArrayBoolean_VTable, get) - 0usize];
452 ["Offset of field: ICapeArrayBoolean_VTable::setsize"]
453 [::std::mem::offset_of!(ICapeArrayBoolean_VTable, setsize) - 8usize];
454};
455#[repr(C)]
456#[derive(Debug, Copy, Clone)]
457pub struct ICapeArrayBoolean {
458 pub me: *mut ::std::os::raw::c_void,
459 #[doc = "!<function pointer table"]
460 pub vTbl: *mut ICapeArrayBoolean_VTable,
461}
462#[allow(clippy::unnecessary_operation, clippy::identity_op)]
463const _: () = {
464 ["Size of ICapeArrayBoolean"][::std::mem::size_of::<ICapeArrayBoolean>() - 16usize];
465 ["Alignment of ICapeArrayBoolean"][::std::mem::align_of::<ICapeArrayBoolean>() - 8usize];
466 ["Offset of field: ICapeArrayBoolean::me"]
467 [::std::mem::offset_of!(ICapeArrayBoolean, me) - 0usize];
468 ["Offset of field: ICapeArrayBoolean::vTbl"]
469 [::std::mem::offset_of!(ICapeArrayBoolean, vTbl) - 8usize];
470};
471#[repr(C)]
472#[derive(Debug, Copy, Clone)]
473pub struct ICapeArrayEnumeration_VTable {
474 pub get: ::std::option::Option<
475 unsafe extern "C" fn(
476 me: *mut ::std::os::raw::c_void,
477 data: *mut *mut CapeEnumeration,
478 size: *mut CapeSize,
479 ),
480 >,
481 pub setsize: ::std::option::Option<
482 unsafe extern "C" fn(
483 me: *mut ::std::os::raw::c_void,
484 size: CapeSize,
485 data: *mut *mut CapeEnumeration,
486 ) -> CapeResult,
487 >,
488}
489#[allow(clippy::unnecessary_operation, clippy::identity_op)]
490const _: () = {
491 ["Size of ICapeArrayEnumeration_VTable"]
492 [::std::mem::size_of::<ICapeArrayEnumeration_VTable>() - 16usize];
493 ["Alignment of ICapeArrayEnumeration_VTable"]
494 [::std::mem::align_of::<ICapeArrayEnumeration_VTable>() - 8usize];
495 ["Offset of field: ICapeArrayEnumeration_VTable::get"]
496 [::std::mem::offset_of!(ICapeArrayEnumeration_VTable, get) - 0usize];
497 ["Offset of field: ICapeArrayEnumeration_VTable::setsize"]
498 [::std::mem::offset_of!(ICapeArrayEnumeration_VTable, setsize) - 8usize];
499};
500#[repr(C)]
501#[derive(Debug, Copy, Clone)]
502pub struct ICapeArrayEnumeration {
503 pub me: *mut ::std::os::raw::c_void,
504 #[doc = "!<function pointer table"]
505 pub vTbl: *mut ICapeArrayEnumeration_VTable,
506}
507#[allow(clippy::unnecessary_operation, clippy::identity_op)]
508const _: () = {
509 ["Size of ICapeArrayEnumeration"][::std::mem::size_of::<ICapeArrayEnumeration>() - 16usize];
510 ["Alignment of ICapeArrayEnumeration"]
511 [::std::mem::align_of::<ICapeArrayEnumeration>() - 8usize];
512 ["Offset of field: ICapeArrayEnumeration::me"]
513 [::std::mem::offset_of!(ICapeArrayEnumeration, me) - 0usize];
514 ["Offset of field: ICapeArrayEnumeration::vTbl"]
515 [::std::mem::offset_of!(ICapeArrayEnumeration, vTbl) - 8usize];
516};
517#[repr(C)]
518#[derive(Debug, Copy, Clone)]
519pub struct ICapeString_VTable {
520 pub get: ::std::option::Option<
521 unsafe extern "C" fn(
522 me: *mut ::std::os::raw::c_void,
523 data: *mut *const CapeCharacter,
524 size: *mut CapeSize,
525 ),
526 >,
527 pub set: ::std::option::Option<
528 unsafe extern "C" fn(
529 me: *mut ::std::os::raw::c_void,
530 data: *const CapeCharacter,
531 size: CapeSize,
532 ) -> CapeResult,
533 >,
534}
535#[allow(clippy::unnecessary_operation, clippy::identity_op)]
536const _: () = {
537 ["Size of ICapeString_VTable"][::std::mem::size_of::<ICapeString_VTable>() - 16usize];
538 ["Alignment of ICapeString_VTable"][::std::mem::align_of::<ICapeString_VTable>() - 8usize];
539 ["Offset of field: ICapeString_VTable::get"]
540 [::std::mem::offset_of!(ICapeString_VTable, get) - 0usize];
541 ["Offset of field: ICapeString_VTable::set"]
542 [::std::mem::offset_of!(ICapeString_VTable, set) - 8usize];
543};
544#[repr(C)]
545#[derive(Debug, Copy, Clone)]
546pub struct _ICapeString {
547 pub me: *mut ::std::os::raw::c_void,
548 #[doc = "!<function pointer table"]
549 pub vTbl: *mut ICapeString_VTable,
550}
551#[allow(clippy::unnecessary_operation, clippy::identity_op)]
552const _: () = {
553 ["Size of _ICapeString"][::std::mem::size_of::<_ICapeString>() - 16usize];
554 ["Alignment of _ICapeString"][::std::mem::align_of::<_ICapeString>() - 8usize];
555 ["Offset of field: _ICapeString::me"][::std::mem::offset_of!(_ICapeString, me) - 0usize];
556 ["Offset of field: _ICapeString::vTbl"][::std::mem::offset_of!(_ICapeString, vTbl) - 8usize];
557};
558pub type ICapeString = _ICapeString;
559#[repr(C)]
560#[derive(Debug, Copy, Clone)]
561pub struct ICapeArrayString_VTable {
562 pub get: ::std::option::Option<
563 unsafe extern "C" fn(
564 me: *mut ::std::os::raw::c_void,
565 data: *mut *mut *mut ICapeString,
566 size: *mut CapeSize,
567 ),
568 >,
569 pub setsize: ::std::option::Option<
570 unsafe extern "C" fn(
571 me: *mut ::std::os::raw::c_void,
572 size: CapeSize,
573 data: *mut *mut *mut ICapeString,
574 ) -> CapeResult,
575 >,
576}
577#[allow(clippy::unnecessary_operation, clippy::identity_op)]
578const _: () = {
579 ["Size of ICapeArrayString_VTable"][::std::mem::size_of::<ICapeArrayString_VTable>() - 16usize];
580 ["Alignment of ICapeArrayString_VTable"]
581 [::std::mem::align_of::<ICapeArrayString_VTable>() - 8usize];
582 ["Offset of field: ICapeArrayString_VTable::get"]
583 [::std::mem::offset_of!(ICapeArrayString_VTable, get) - 0usize];
584 ["Offset of field: ICapeArrayString_VTable::setsize"]
585 [::std::mem::offset_of!(ICapeArrayString_VTable, setsize) - 8usize];
586};
587#[repr(C)]
588#[derive(Debug, Copy, Clone)]
589pub struct ICapeArrayString {
590 pub me: *mut ::std::os::raw::c_void,
591 #[doc = "!<function pointer table"]
592 pub vTbl: *mut ICapeArrayString_VTable,
593}
594#[allow(clippy::unnecessary_operation, clippy::identity_op)]
595const _: () = {
596 ["Size of ICapeArrayString"][::std::mem::size_of::<ICapeArrayString>() - 16usize];
597 ["Alignment of ICapeArrayString"][::std::mem::align_of::<ICapeArrayString>() - 8usize];
598 ["Offset of field: ICapeArrayString::me"]
599 [::std::mem::offset_of!(ICapeArrayString, me) - 0usize];
600 ["Offset of field: ICapeArrayString::vTbl"]
601 [::std::mem::offset_of!(ICapeArrayString, vTbl) - 8usize];
602};
603#[repr(C)]
604#[derive(Debug, Copy, Clone)]
605pub struct ICapeValue_VTable {
606 pub getValueType: ::std::option::Option<
607 unsafe extern "C" fn(me: *mut ::std::os::raw::c_void) -> CapeValueType,
608 >,
609 pub getStringValue: ::std::option::Option<
610 unsafe extern "C" fn(
611 me: *mut ::std::os::raw::c_void,
612 data: *mut *const CapeCharacter,
613 size: *mut CapeSize,
614 ) -> CapeResult,
615 >,
616 pub getIntegerValue: ::std::option::Option<
617 unsafe extern "C" fn(
618 me: *mut ::std::os::raw::c_void,
619 value: *mut CapeInteger,
620 ) -> CapeResult,
621 >,
622 pub getBooleanValue: ::std::option::Option<
623 unsafe extern "C" fn(
624 me: *mut ::std::os::raw::c_void,
625 value: *mut CapeBoolean,
626 ) -> CapeResult,
627 >,
628 pub getRealValue: ::std::option::Option<
629 unsafe extern "C" fn(me: *mut ::std::os::raw::c_void, value: *mut CapeReal) -> CapeResult,
630 >,
631 pub setStringValue: ::std::option::Option<
632 unsafe extern "C" fn(
633 me: *mut ::std::os::raw::c_void,
634 data: *const CapeCharacter,
635 size: CapeSize,
636 ) -> CapeResult,
637 >,
638 pub setIntegerValue: ::std::option::Option<
639 unsafe extern "C" fn(me: *mut ::std::os::raw::c_void, value: CapeInteger) -> CapeResult,
640 >,
641 pub setBooleanValue: ::std::option::Option<
642 unsafe extern "C" fn(me: *mut ::std::os::raw::c_void, value: CapeBoolean) -> CapeResult,
643 >,
644 pub setRealValue: ::std::option::Option<
645 unsafe extern "C" fn(me: *mut ::std::os::raw::c_void, value: CapeReal) -> CapeResult,
646 >,
647 pub clear:
648 ::std::option::Option<unsafe extern "C" fn(me: *mut ::std::os::raw::c_void) -> CapeResult>,
649}
650#[allow(clippy::unnecessary_operation, clippy::identity_op)]
651const _: () = {
652 ["Size of ICapeValue_VTable"][::std::mem::size_of::<ICapeValue_VTable>() - 80usize];
653 ["Alignment of ICapeValue_VTable"][::std::mem::align_of::<ICapeValue_VTable>() - 8usize];
654 ["Offset of field: ICapeValue_VTable::getValueType"]
655 [::std::mem::offset_of!(ICapeValue_VTable, getValueType) - 0usize];
656 ["Offset of field: ICapeValue_VTable::getStringValue"]
657 [::std::mem::offset_of!(ICapeValue_VTable, getStringValue) - 8usize];
658 ["Offset of field: ICapeValue_VTable::getIntegerValue"]
659 [::std::mem::offset_of!(ICapeValue_VTable, getIntegerValue) - 16usize];
660 ["Offset of field: ICapeValue_VTable::getBooleanValue"]
661 [::std::mem::offset_of!(ICapeValue_VTable, getBooleanValue) - 24usize];
662 ["Offset of field: ICapeValue_VTable::getRealValue"]
663 [::std::mem::offset_of!(ICapeValue_VTable, getRealValue) - 32usize];
664 ["Offset of field: ICapeValue_VTable::setStringValue"]
665 [::std::mem::offset_of!(ICapeValue_VTable, setStringValue) - 40usize];
666 ["Offset of field: ICapeValue_VTable::setIntegerValue"]
667 [::std::mem::offset_of!(ICapeValue_VTable, setIntegerValue) - 48usize];
668 ["Offset of field: ICapeValue_VTable::setBooleanValue"]
669 [::std::mem::offset_of!(ICapeValue_VTable, setBooleanValue) - 56usize];
670 ["Offset of field: ICapeValue_VTable::setRealValue"]
671 [::std::mem::offset_of!(ICapeValue_VTable, setRealValue) - 64usize];
672 ["Offset of field: ICapeValue_VTable::clear"]
673 [::std::mem::offset_of!(ICapeValue_VTable, clear) - 72usize];
674};
675#[repr(C)]
676#[derive(Debug, Copy, Clone)]
677pub struct ICapeValue {
678 #[doc = "!<object pointer"]
679 pub me: *mut ::std::os::raw::c_void,
680 #[doc = "!<function pointer table"]
681 pub vTbl: *mut ICapeValue_VTable,
682}
683#[allow(clippy::unnecessary_operation, clippy::identity_op)]
684const _: () = {
685 ["Size of ICapeValue"][::std::mem::size_of::<ICapeValue>() - 16usize];
686 ["Alignment of ICapeValue"][::std::mem::align_of::<ICapeValue>() - 8usize];
687 ["Offset of field: ICapeValue::me"][::std::mem::offset_of!(ICapeValue, me) - 0usize];
688 ["Offset of field: ICapeValue::vTbl"][::std::mem::offset_of!(ICapeValue, vTbl) - 8usize];
689};
690#[repr(C)]
691#[derive(Debug, Copy, Clone)]
692pub struct ICapeArrayValue_VTable {
693 pub get: ::std::option::Option<
694 unsafe extern "C" fn(
695 me: *mut ::std::os::raw::c_void,
696 data: *mut *mut *mut ICapeValue,
697 size: *mut CapeSize,
698 ),
699 >,
700 pub setsize: ::std::option::Option<
701 unsafe extern "C" fn(
702 me: *mut ::std::os::raw::c_void,
703 size: CapeSize,
704 data: *mut *mut *mut ICapeValue,
705 ) -> CapeResult,
706 >,
707}
708#[allow(clippy::unnecessary_operation, clippy::identity_op)]
709const _: () = {
710 ["Size of ICapeArrayValue_VTable"][::std::mem::size_of::<ICapeArrayValue_VTable>() - 16usize];
711 ["Alignment of ICapeArrayValue_VTable"]
712 [::std::mem::align_of::<ICapeArrayValue_VTable>() - 8usize];
713 ["Offset of field: ICapeArrayValue_VTable::get"]
714 [::std::mem::offset_of!(ICapeArrayValue_VTable, get) - 0usize];
715 ["Offset of field: ICapeArrayValue_VTable::setsize"]
716 [::std::mem::offset_of!(ICapeArrayValue_VTable, setsize) - 8usize];
717};
718#[repr(C)]
719#[derive(Debug, Copy, Clone)]
720pub struct ICapeArrayValue {
721 pub me: *mut ::std::os::raw::c_void,
722 #[doc = "!<function pointer table"]
723 pub vTbl: *mut ICapeArrayValue_VTable,
724}
725#[allow(clippy::unnecessary_operation, clippy::identity_op)]
726const _: () = {
727 ["Size of ICapeArrayValue"][::std::mem::size_of::<ICapeArrayValue>() - 16usize];
728 ["Alignment of ICapeArrayValue"][::std::mem::align_of::<ICapeArrayValue>() - 8usize];
729 ["Offset of field: ICapeArrayValue::me"][::std::mem::offset_of!(ICapeArrayValue, me) - 0usize];
730 ["Offset of field: ICapeArrayValue::vTbl"]
731 [::std::mem::offset_of!(ICapeArrayValue, vTbl) - 8usize];
732};
733#[repr(C)]
734#[derive(Debug, Copy, Clone)]
735pub struct ICobiaCollection_VTable {
736 pub base: ICapeInterface_VTable,
737 pub ItemByIndex: ::std::option::Option<
738 unsafe extern "C" fn(
739 me: *mut ::std::os::raw::c_void,
740 index: CapeInteger,
741 item: *mut *mut ICapeInterface,
742 ) -> CapeResult,
743 >,
744 pub ItemByName: ::std::option::Option<
745 unsafe extern "C" fn(
746 me: *mut ::std::os::raw::c_void,
747 name: *mut ICapeString,
748 item: *mut *mut ICapeInterface,
749 ) -> CapeResult,
750 >,
751 pub getCount: ::std::option::Option<
752 unsafe extern "C" fn(
753 me: *mut ::std::os::raw::c_void,
754 itemCount: *mut CapeInteger,
755 ) -> CapeResult,
756 >,
757}
758#[allow(clippy::unnecessary_operation, clippy::identity_op)]
759const _: () = {
760 ["Size of ICobiaCollection_VTable"][::std::mem::size_of::<ICobiaCollection_VTable>() - 56usize];
761 ["Alignment of ICobiaCollection_VTable"]
762 [::std::mem::align_of::<ICobiaCollection_VTable>() - 8usize];
763 ["Offset of field: ICobiaCollection_VTable::base"]
764 [::std::mem::offset_of!(ICobiaCollection_VTable, base) - 0usize];
765 ["Offset of field: ICobiaCollection_VTable::ItemByIndex"]
766 [::std::mem::offset_of!(ICobiaCollection_VTable, ItemByIndex) - 32usize];
767 ["Offset of field: ICobiaCollection_VTable::ItemByName"]
768 [::std::mem::offset_of!(ICobiaCollection_VTable, ItemByName) - 40usize];
769 ["Offset of field: ICobiaCollection_VTable::getCount"]
770 [::std::mem::offset_of!(ICobiaCollection_VTable, getCount) - 48usize];
771};
772#[repr(C)]
773#[derive(Debug, Copy, Clone)]
774pub struct ICobiaCollection {
775 #[doc = "!<object pointer"]
776 pub me: *mut ::std::os::raw::c_void,
777 #[doc = "!<function pointer table"]
778 pub vTbl: *mut ICobiaCollection_VTable,
779}
780#[allow(clippy::unnecessary_operation, clippy::identity_op)]
781const _: () = {
782 ["Size of ICobiaCollection"][::std::mem::size_of::<ICobiaCollection>() - 16usize];
783 ["Alignment of ICobiaCollection"][::std::mem::align_of::<ICobiaCollection>() - 8usize];
784 ["Offset of field: ICobiaCollection::me"]
785 [::std::mem::offset_of!(ICobiaCollection, me) - 0usize];
786 ["Offset of field: ICobiaCollection::vTbl"]
787 [::std::mem::offset_of!(ICobiaCollection, vTbl) - 8usize];
788};
789#[repr(C)]
790#[derive(Debug, Copy, Clone)]
791pub struct ICobiaIdentification_VTable {
792 pub base: ICapeInterface_VTable,
793 pub getComponentName: ::std::option::Option<
794 unsafe extern "C" fn(me: *mut ::std::os::raw::c_void, name: *mut ICapeString) -> CapeResult,
795 >,
796 pub putComponentName: ::std::option::Option<
797 unsafe extern "C" fn(me: *mut ::std::os::raw::c_void, name: *mut ICapeString) -> CapeResult,
798 >,
799 pub getComponentDescription: ::std::option::Option<
800 unsafe extern "C" fn(me: *mut ::std::os::raw::c_void, desc: *mut ICapeString) -> CapeResult,
801 >,
802 pub putComponentDescription: ::std::option::Option<
803 unsafe extern "C" fn(me: *mut ::std::os::raw::c_void, desc: *mut ICapeString) -> CapeResult,
804 >,
805}
806#[allow(clippy::unnecessary_operation, clippy::identity_op)]
807const _: () = {
808 ["Size of ICobiaIdentification_VTable"]
809 [::std::mem::size_of::<ICobiaIdentification_VTable>() - 64usize];
810 ["Alignment of ICobiaIdentification_VTable"]
811 [::std::mem::align_of::<ICobiaIdentification_VTable>() - 8usize];
812 ["Offset of field: ICobiaIdentification_VTable::base"]
813 [::std::mem::offset_of!(ICobiaIdentification_VTable, base) - 0usize];
814 ["Offset of field: ICobiaIdentification_VTable::getComponentName"]
815 [::std::mem::offset_of!(ICobiaIdentification_VTable, getComponentName) - 32usize];
816 ["Offset of field: ICobiaIdentification_VTable::putComponentName"]
817 [::std::mem::offset_of!(ICobiaIdentification_VTable, putComponentName) - 40usize];
818 ["Offset of field: ICobiaIdentification_VTable::getComponentDescription"]
819 [::std::mem::offset_of!(ICobiaIdentification_VTable, getComponentDescription) - 48usize];
820 ["Offset of field: ICobiaIdentification_VTable::putComponentDescription"]
821 [::std::mem::offset_of!(ICobiaIdentification_VTable, putComponentDescription) - 56usize];
822};
823#[repr(C)]
824#[derive(Debug, Copy, Clone)]
825pub struct ICobiaIdentification {
826 #[doc = "!<object pointer"]
827 pub me: *mut ::std::os::raw::c_void,
828 #[doc = "!<function pointer table"]
829 pub vTbl: *mut ICobiaIdentification_VTable,
830}
831#[allow(clippy::unnecessary_operation, clippy::identity_op)]
832const _: () = {
833 ["Size of ICobiaIdentification"][::std::mem::size_of::<ICobiaIdentification>() - 16usize];
834 ["Alignment of ICobiaIdentification"][::std::mem::align_of::<ICobiaIdentification>() - 8usize];
835 ["Offset of field: ICobiaIdentification::me"]
836 [::std::mem::offset_of!(ICobiaIdentification, me) - 0usize];
837 ["Offset of field: ICobiaIdentification::vTbl"]
838 [::std::mem::offset_of!(ICobiaIdentification, vTbl) - 8usize];
839};
840unsafe extern "C" {
841 pub static ICapeInterface_UUID: CapeUUID;
842}
843unsafe extern "C" {
844 pub static ICapeError_UUID: CapeUUID;
845}
846unsafe extern "C" {
847 pub static ICobiaCollection_UUID: CapeUUID;
848}
849unsafe extern "C" {
850 pub static ICobiaIdentification_UUID: CapeUUID;
851}
852#[repr(C)]
853#[derive(Debug, Copy, Clone)]
854pub struct ICobiaArrayReal_VTable {
855 #[doc = "!< ICapeArrayReal vTable"]
856 pub base: ICapeArrayReal_VTable,
857 pub destroy: ::std::option::Option<unsafe extern "C" fn(me: *mut ::std::os::raw::c_void)>,
858}
859#[allow(clippy::unnecessary_operation, clippy::identity_op)]
860const _: () = {
861 ["Size of ICobiaArrayReal_VTable"][::std::mem::size_of::<ICobiaArrayReal_VTable>() - 24usize];
862 ["Alignment of ICobiaArrayReal_VTable"]
863 [::std::mem::align_of::<ICobiaArrayReal_VTable>() - 8usize];
864 ["Offset of field: ICobiaArrayReal_VTable::base"]
865 [::std::mem::offset_of!(ICobiaArrayReal_VTable, base) - 0usize];
866 ["Offset of field: ICobiaArrayReal_VTable::destroy"]
867 [::std::mem::offset_of!(ICobiaArrayReal_VTable, destroy) - 16usize];
868};
869#[repr(C)]
870#[derive(Debug, Copy, Clone)]
871pub struct ICobiaArrayReal {
872 pub me: *mut ::std::os::raw::c_void,
873 pub vTbl: *mut ICobiaArrayReal_VTable,
874}
875#[allow(clippy::unnecessary_operation, clippy::identity_op)]
876const _: () = {
877 ["Size of ICobiaArrayReal"][::std::mem::size_of::<ICobiaArrayReal>() - 16usize];
878 ["Alignment of ICobiaArrayReal"][::std::mem::align_of::<ICobiaArrayReal>() - 8usize];
879 ["Offset of field: ICobiaArrayReal::me"][::std::mem::offset_of!(ICobiaArrayReal, me) - 0usize];
880 ["Offset of field: ICobiaArrayReal::vTbl"]
881 [::std::mem::offset_of!(ICobiaArrayReal, vTbl) - 8usize];
882};
883#[repr(C)]
884#[derive(Debug, Copy, Clone)]
885pub struct ICobiaArrayInteger_VTable {
886 #[doc = "!< ICapeArrayInteger class"]
887 pub base: ICapeArrayInteger_VTable,
888 pub destroy: ::std::option::Option<unsafe extern "C" fn(me: *mut ::std::os::raw::c_void)>,
889}
890#[allow(clippy::unnecessary_operation, clippy::identity_op)]
891const _: () = {
892 ["Size of ICobiaArrayInteger_VTable"]
893 [::std::mem::size_of::<ICobiaArrayInteger_VTable>() - 24usize];
894 ["Alignment of ICobiaArrayInteger_VTable"]
895 [::std::mem::align_of::<ICobiaArrayInteger_VTable>() - 8usize];
896 ["Offset of field: ICobiaArrayInteger_VTable::base"]
897 [::std::mem::offset_of!(ICobiaArrayInteger_VTable, base) - 0usize];
898 ["Offset of field: ICobiaArrayInteger_VTable::destroy"]
899 [::std::mem::offset_of!(ICobiaArrayInteger_VTable, destroy) - 16usize];
900};
901#[repr(C)]
902#[derive(Debug, Copy, Clone)]
903pub struct ICobiaArrayInteger {
904 pub me: *mut ::std::os::raw::c_void,
905 pub vTbl: *mut ICobiaArrayInteger_VTable,
906}
907#[allow(clippy::unnecessary_operation, clippy::identity_op)]
908const _: () = {
909 ["Size of ICobiaArrayInteger"][::std::mem::size_of::<ICobiaArrayInteger>() - 16usize];
910 ["Alignment of ICobiaArrayInteger"][::std::mem::align_of::<ICobiaArrayInteger>() - 8usize];
911 ["Offset of field: ICobiaArrayInteger::me"]
912 [::std::mem::offset_of!(ICobiaArrayInteger, me) - 0usize];
913 ["Offset of field: ICobiaArrayInteger::vTbl"]
914 [::std::mem::offset_of!(ICobiaArrayInteger, vTbl) - 8usize];
915};
916#[repr(C)]
917#[derive(Debug, Copy, Clone)]
918pub struct ICobiaArrayByte_VTable {
919 #[doc = "!< ICapeArrayByte class"]
920 pub base: ICapeArrayByte_VTable,
921 pub destroy: ::std::option::Option<unsafe extern "C" fn(me: *mut ::std::os::raw::c_void)>,
922}
923#[allow(clippy::unnecessary_operation, clippy::identity_op)]
924const _: () = {
925 ["Size of ICobiaArrayByte_VTable"][::std::mem::size_of::<ICobiaArrayByte_VTable>() - 24usize];
926 ["Alignment of ICobiaArrayByte_VTable"]
927 [::std::mem::align_of::<ICobiaArrayByte_VTable>() - 8usize];
928 ["Offset of field: ICobiaArrayByte_VTable::base"]
929 [::std::mem::offset_of!(ICobiaArrayByte_VTable, base) - 0usize];
930 ["Offset of field: ICobiaArrayByte_VTable::destroy"]
931 [::std::mem::offset_of!(ICobiaArrayByte_VTable, destroy) - 16usize];
932};
933#[repr(C)]
934#[derive(Debug, Copy, Clone)]
935pub struct ICobiaArrayByte {
936 pub me: *mut ::std::os::raw::c_void,
937 pub vTbl: *mut ICobiaArrayByte_VTable,
938}
939#[allow(clippy::unnecessary_operation, clippy::identity_op)]
940const _: () = {
941 ["Size of ICobiaArrayByte"][::std::mem::size_of::<ICobiaArrayByte>() - 16usize];
942 ["Alignment of ICobiaArrayByte"][::std::mem::align_of::<ICobiaArrayByte>() - 8usize];
943 ["Offset of field: ICobiaArrayByte::me"][::std::mem::offset_of!(ICobiaArrayByte, me) - 0usize];
944 ["Offset of field: ICobiaArrayByte::vTbl"]
945 [::std::mem::offset_of!(ICobiaArrayByte, vTbl) - 8usize];
946};
947#[repr(C)]
948#[derive(Debug, Copy, Clone)]
949pub struct ICobiaArrayBoolean_VTable {
950 #[doc = "!< ICapeArrayBoolean class"]
951 pub base: ICapeArrayBoolean_VTable,
952 pub destroy: ::std::option::Option<unsafe extern "C" fn(me: *mut ::std::os::raw::c_void)>,
953}
954#[allow(clippy::unnecessary_operation, clippy::identity_op)]
955const _: () = {
956 ["Size of ICobiaArrayBoolean_VTable"]
957 [::std::mem::size_of::<ICobiaArrayBoolean_VTable>() - 24usize];
958 ["Alignment of ICobiaArrayBoolean_VTable"]
959 [::std::mem::align_of::<ICobiaArrayBoolean_VTable>() - 8usize];
960 ["Offset of field: ICobiaArrayBoolean_VTable::base"]
961 [::std::mem::offset_of!(ICobiaArrayBoolean_VTable, base) - 0usize];
962 ["Offset of field: ICobiaArrayBoolean_VTable::destroy"]
963 [::std::mem::offset_of!(ICobiaArrayBoolean_VTable, destroy) - 16usize];
964};
965#[repr(C)]
966#[derive(Debug, Copy, Clone)]
967pub struct ICobiaArrayBoolean {
968 pub me: *mut ::std::os::raw::c_void,
969 pub vTbl: *mut ICobiaArrayBoolean_VTable,
970}
971#[allow(clippy::unnecessary_operation, clippy::identity_op)]
972const _: () = {
973 ["Size of ICobiaArrayBoolean"][::std::mem::size_of::<ICobiaArrayBoolean>() - 16usize];
974 ["Alignment of ICobiaArrayBoolean"][::std::mem::align_of::<ICobiaArrayBoolean>() - 8usize];
975 ["Offset of field: ICobiaArrayBoolean::me"]
976 [::std::mem::offset_of!(ICobiaArrayBoolean, me) - 0usize];
977 ["Offset of field: ICobiaArrayBoolean::vTbl"]
978 [::std::mem::offset_of!(ICobiaArrayBoolean, vTbl) - 8usize];
979};
980#[repr(C)]
981#[derive(Debug, Copy, Clone)]
982pub struct ICobiaArrayEnumeration_VTable {
983 #[doc = "!<ICapeArrayEnumeration class"]
984 pub base: ICapeArrayEnumeration_VTable,
985 pub destroy: ::std::option::Option<unsafe extern "C" fn(me: *mut ::std::os::raw::c_void)>,
986}
987#[allow(clippy::unnecessary_operation, clippy::identity_op)]
988const _: () = {
989 ["Size of ICobiaArrayEnumeration_VTable"]
990 [::std::mem::size_of::<ICobiaArrayEnumeration_VTable>() - 24usize];
991 ["Alignment of ICobiaArrayEnumeration_VTable"]
992 [::std::mem::align_of::<ICobiaArrayEnumeration_VTable>() - 8usize];
993 ["Offset of field: ICobiaArrayEnumeration_VTable::base"]
994 [::std::mem::offset_of!(ICobiaArrayEnumeration_VTable, base) - 0usize];
995 ["Offset of field: ICobiaArrayEnumeration_VTable::destroy"]
996 [::std::mem::offset_of!(ICobiaArrayEnumeration_VTable, destroy) - 16usize];
997};
998#[repr(C)]
999#[derive(Debug, Copy, Clone)]
1000pub struct ICobiaArrayEnumeration {
1001 pub me: *mut ::std::os::raw::c_void,
1002 pub vTbl: *mut ICobiaArrayEnumeration_VTable,
1003}
1004#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1005const _: () = {
1006 ["Size of ICobiaArrayEnumeration"][::std::mem::size_of::<ICobiaArrayEnumeration>() - 16usize];
1007 ["Alignment of ICobiaArrayEnumeration"]
1008 [::std::mem::align_of::<ICobiaArrayEnumeration>() - 8usize];
1009 ["Offset of field: ICobiaArrayEnumeration::me"]
1010 [::std::mem::offset_of!(ICobiaArrayEnumeration, me) - 0usize];
1011 ["Offset of field: ICobiaArrayEnumeration::vTbl"]
1012 [::std::mem::offset_of!(ICobiaArrayEnumeration, vTbl) - 8usize];
1013};
1014#[repr(C)]
1015#[derive(Debug, Copy, Clone)]
1016pub struct ICobiaString_VTable {
1017 #[doc = "!< ICapeString class"]
1018 pub base: ICapeString_VTable,
1019 pub destroy: ::std::option::Option<unsafe extern "C" fn(me: *mut ::std::os::raw::c_void)>,
1020}
1021#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1022const _: () = {
1023 ["Size of ICobiaString_VTable"][::std::mem::size_of::<ICobiaString_VTable>() - 24usize];
1024 ["Alignment of ICobiaString_VTable"][::std::mem::align_of::<ICobiaString_VTable>() - 8usize];
1025 ["Offset of field: ICobiaString_VTable::base"]
1026 [::std::mem::offset_of!(ICobiaString_VTable, base) - 0usize];
1027 ["Offset of field: ICobiaString_VTable::destroy"]
1028 [::std::mem::offset_of!(ICobiaString_VTable, destroy) - 16usize];
1029};
1030#[repr(C)]
1031#[derive(Debug, Copy, Clone)]
1032pub struct ICobiaString {
1033 pub me: *mut ::std::os::raw::c_void,
1034 pub vTbl: *mut ICobiaString_VTable,
1035}
1036#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1037const _: () = {
1038 ["Size of ICobiaString"][::std::mem::size_of::<ICobiaString>() - 16usize];
1039 ["Alignment of ICobiaString"][::std::mem::align_of::<ICobiaString>() - 8usize];
1040 ["Offset of field: ICobiaString::me"][::std::mem::offset_of!(ICobiaString, me) - 0usize];
1041 ["Offset of field: ICobiaString::vTbl"][::std::mem::offset_of!(ICobiaString, vTbl) - 8usize];
1042};
1043#[repr(C)]
1044#[derive(Debug, Copy, Clone)]
1045pub struct ICobiaArrayString_VTable {
1046 pub base: ICapeArrayString_VTable,
1047 pub destroy: ::std::option::Option<unsafe extern "C" fn(me: *mut ::std::os::raw::c_void)>,
1048}
1049#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1050const _: () = {
1051 ["Size of ICobiaArrayString_VTable"]
1052 [::std::mem::size_of::<ICobiaArrayString_VTable>() - 24usize];
1053 ["Alignment of ICobiaArrayString_VTable"]
1054 [::std::mem::align_of::<ICobiaArrayString_VTable>() - 8usize];
1055 ["Offset of field: ICobiaArrayString_VTable::base"]
1056 [::std::mem::offset_of!(ICobiaArrayString_VTable, base) - 0usize];
1057 ["Offset of field: ICobiaArrayString_VTable::destroy"]
1058 [::std::mem::offset_of!(ICobiaArrayString_VTable, destroy) - 16usize];
1059};
1060#[repr(C)]
1061#[derive(Debug, Copy, Clone)]
1062pub struct ICobiaArrayString {
1063 pub me: *mut ::std::os::raw::c_void,
1064 pub vTbl: *mut ICobiaArrayString_VTable,
1065}
1066#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1067const _: () = {
1068 ["Size of ICobiaArrayString"][::std::mem::size_of::<ICobiaArrayString>() - 16usize];
1069 ["Alignment of ICobiaArrayString"][::std::mem::align_of::<ICobiaArrayString>() - 8usize];
1070 ["Offset of field: ICobiaArrayString::me"]
1071 [::std::mem::offset_of!(ICobiaArrayString, me) - 0usize];
1072 ["Offset of field: ICobiaArrayString::vTbl"]
1073 [::std::mem::offset_of!(ICobiaArrayString, vTbl) - 8usize];
1074};
1075#[repr(C)]
1076#[derive(Debug, Copy, Clone)]
1077pub struct ICobiaValue_VTable {
1078 pub base: ICapeValue_VTable,
1079 pub destroy: ::std::option::Option<unsafe extern "C" fn(me: *mut ::std::os::raw::c_void)>,
1080}
1081#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1082const _: () = {
1083 ["Size of ICobiaValue_VTable"][::std::mem::size_of::<ICobiaValue_VTable>() - 88usize];
1084 ["Alignment of ICobiaValue_VTable"][::std::mem::align_of::<ICobiaValue_VTable>() - 8usize];
1085 ["Offset of field: ICobiaValue_VTable::base"]
1086 [::std::mem::offset_of!(ICobiaValue_VTable, base) - 0usize];
1087 ["Offset of field: ICobiaValue_VTable::destroy"]
1088 [::std::mem::offset_of!(ICobiaValue_VTable, destroy) - 80usize];
1089};
1090#[repr(C)]
1091#[derive(Debug, Copy, Clone)]
1092pub struct ICobiaValue {
1093 pub me: *mut ::std::os::raw::c_void,
1094 pub vTbl: *mut ICobiaValue_VTable,
1095}
1096#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1097const _: () = {
1098 ["Size of ICobiaValue"][::std::mem::size_of::<ICobiaValue>() - 16usize];
1099 ["Alignment of ICobiaValue"][::std::mem::align_of::<ICobiaValue>() - 8usize];
1100 ["Offset of field: ICobiaValue::me"][::std::mem::offset_of!(ICobiaValue, me) - 0usize];
1101 ["Offset of field: ICobiaValue::vTbl"][::std::mem::offset_of!(ICobiaValue, vTbl) - 8usize];
1102};
1103#[repr(C)]
1104#[derive(Debug, Copy, Clone)]
1105pub struct ICobiaArrayValue_VTable {
1106 #[doc = "!<ICapeArrayValue class"]
1107 pub base: ICapeArrayValue_VTable,
1108 pub destroy: ::std::option::Option<unsafe extern "C" fn(me: *mut ::std::os::raw::c_void)>,
1109}
1110#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1111const _: () = {
1112 ["Size of ICobiaArrayValue_VTable"][::std::mem::size_of::<ICobiaArrayValue_VTable>() - 24usize];
1113 ["Alignment of ICobiaArrayValue_VTable"]
1114 [::std::mem::align_of::<ICobiaArrayValue_VTable>() - 8usize];
1115 ["Offset of field: ICobiaArrayValue_VTable::base"]
1116 [::std::mem::offset_of!(ICobiaArrayValue_VTable, base) - 0usize];
1117 ["Offset of field: ICobiaArrayValue_VTable::destroy"]
1118 [::std::mem::offset_of!(ICobiaArrayValue_VTable, destroy) - 16usize];
1119};
1120#[repr(C)]
1121#[derive(Debug, Copy, Clone)]
1122pub struct ICobiaArrayValue {
1123 pub me: *mut ::std::os::raw::c_void,
1124 pub vTbl: *mut ICobiaArrayValue_VTable,
1125}
1126#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1127const _: () = {
1128 ["Size of ICobiaArrayValue"][::std::mem::size_of::<ICobiaArrayValue>() - 16usize];
1129 ["Alignment of ICobiaArrayValue"][::std::mem::align_of::<ICobiaArrayValue>() - 8usize];
1130 ["Offset of field: ICobiaArrayValue::me"]
1131 [::std::mem::offset_of!(ICobiaArrayValue, me) - 0usize];
1132 ["Offset of field: ICobiaArrayValue::vTbl"]
1133 [::std::mem::offset_of!(ICobiaArrayValue, vTbl) - 8usize];
1134};
1135#[repr(C)]
1136#[derive(Debug, Copy, Clone)]
1137pub struct ICobiaDataClassFactory {
1138 pub createCobiaString: ::std::option::Option<unsafe extern "C" fn() -> *mut ICobiaString>,
1139 pub createCobiaValue: ::std::option::Option<unsafe extern "C" fn() -> *mut ICobiaValue>,
1140 pub createCobiaArrayReal: ::std::option::Option<unsafe extern "C" fn() -> *mut ICobiaArrayReal>,
1141 pub createCobiaArrayInteger:
1142 ::std::option::Option<unsafe extern "C" fn() -> *mut ICobiaArrayInteger>,
1143 pub createCobiaArrayByte: ::std::option::Option<unsafe extern "C" fn() -> *mut ICobiaArrayByte>,
1144 pub createCobiaArrayBoolean:
1145 ::std::option::Option<unsafe extern "C" fn() -> *mut ICobiaArrayBoolean>,
1146 pub createCobiaArrayEnumeration:
1147 ::std::option::Option<unsafe extern "C" fn() -> *mut ICobiaArrayEnumeration>,
1148 pub createCobiaArrayString:
1149 ::std::option::Option<unsafe extern "C" fn() -> *mut ICobiaArrayString>,
1150 pub createCobiaArrayValue:
1151 ::std::option::Option<unsafe extern "C" fn() -> *mut ICobiaArrayValue>,
1152}
1153#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1154const _: () = {
1155 ["Size of ICobiaDataClassFactory"][::std::mem::size_of::<ICobiaDataClassFactory>() - 72usize];
1156 ["Alignment of ICobiaDataClassFactory"]
1157 [::std::mem::align_of::<ICobiaDataClassFactory>() - 8usize];
1158 ["Offset of field: ICobiaDataClassFactory::createCobiaString"]
1159 [::std::mem::offset_of!(ICobiaDataClassFactory, createCobiaString) - 0usize];
1160 ["Offset of field: ICobiaDataClassFactory::createCobiaValue"]
1161 [::std::mem::offset_of!(ICobiaDataClassFactory, createCobiaValue) - 8usize];
1162 ["Offset of field: ICobiaDataClassFactory::createCobiaArrayReal"]
1163 [::std::mem::offset_of!(ICobiaDataClassFactory, createCobiaArrayReal) - 16usize];
1164 ["Offset of field: ICobiaDataClassFactory::createCobiaArrayInteger"]
1165 [::std::mem::offset_of!(ICobiaDataClassFactory, createCobiaArrayInteger) - 24usize];
1166 ["Offset of field: ICobiaDataClassFactory::createCobiaArrayByte"]
1167 [::std::mem::offset_of!(ICobiaDataClassFactory, createCobiaArrayByte) - 32usize];
1168 ["Offset of field: ICobiaDataClassFactory::createCobiaArrayBoolean"]
1169 [::std::mem::offset_of!(ICobiaDataClassFactory, createCobiaArrayBoolean) - 40usize];
1170 ["Offset of field: ICobiaDataClassFactory::createCobiaArrayEnumeration"]
1171 [::std::mem::offset_of!(ICobiaDataClassFactory, createCobiaArrayEnumeration) - 48usize];
1172 ["Offset of field: ICobiaDataClassFactory::createCobiaArrayString"]
1173 [::std::mem::offset_of!(ICobiaDataClassFactory, createCobiaArrayString) - 56usize];
1174 ["Offset of field: ICobiaDataClassFactory::createCobiaArrayValue"]
1175 [::std::mem::offset_of!(ICobiaDataClassFactory, createCobiaArrayValue) - 64usize];
1176};
1177pub const eCapePMCRegistrationFlags_CapePMCRegistrationFlag_None: eCapePMCRegistrationFlags = 0;
1178pub const eCapePMCRegistrationFlags_CapePMCRegistrationFlag_RestrictedThreading:
1179 eCapePMCRegistrationFlags = 1;
1180#[doc = "! PMC registration flags\n*!\nBit flags for PMC registration\n*/"]
1181pub type eCapePMCRegistrationFlags = i32;
1182#[doc = "! PMC registration flags\n*!\nBit flags for PMC registration\n*/"]
1183pub use self::eCapePMCRegistrationFlags as CapePMCRegistrationFlags;
1184pub const eCapePMCCreationFlags_CapePMCCreationFlag_Default: eCapePMCCreationFlags = 0;
1185pub const eCapePMCCreationFlags_CapePMCCreationFlag_AllowRestrictedThreading:
1186 eCapePMCCreationFlags = 1;
1187#[doc = "! PMC creation flags\n*!\nBit flags for PMC creation\n*/"]
1188pub type eCapePMCCreationFlags = i32;
1189#[doc = "! PMC creation flags\n*!\nBit flags for PMC creation\n*/"]
1190pub use self::eCapePMCCreationFlags as CapePMCCreationFlags;
1191#[repr(C)]
1192#[derive(Debug, Copy, Clone)]
1193pub struct ICapeRegistryKey_VTable {
1194 pub base: ICobiaBase_VTable,
1195 pub getValues: ::std::option::Option<
1196 unsafe extern "C" fn(
1197 me: *mut ::std::os::raw::c_void,
1198 valueNames: *mut ICapeArrayString,
1199 ) -> CapeResult,
1200 >,
1201 pub getValueType: ::std::option::Option<
1202 unsafe extern "C" fn(
1203 me: *mut ::std::os::raw::c_void,
1204 valueName: *const CapeCharacter,
1205 subKey: *const CapeCharacter,
1206 regValType: *mut CapeRegistryValueType,
1207 ) -> CapeResult,
1208 >,
1209 pub getStringValue: ::std::option::Option<
1210 unsafe extern "C" fn(
1211 me: *mut ::std::os::raw::c_void,
1212 valueName: *const CapeCharacter,
1213 subKey: *const CapeCharacter,
1214 value: *mut ICapeString,
1215 ) -> CapeResult,
1216 >,
1217 pub getIntegerValue: ::std::option::Option<
1218 unsafe extern "C" fn(
1219 me: *mut ::std::os::raw::c_void,
1220 valueName: *const CapeCharacter,
1221 subKey: *const CapeCharacter,
1222 value: *mut CapeInteger,
1223 ) -> CapeResult,
1224 >,
1225 pub getUUIDValue: ::std::option::Option<
1226 unsafe extern "C" fn(
1227 me: *mut ::std::os::raw::c_void,
1228 valueName: *const CapeCharacter,
1229 subKey: *const CapeCharacter,
1230 value: *mut CapeUUID,
1231 ) -> CapeResult,
1232 >,
1233 pub getKeys: ::std::option::Option<
1234 unsafe extern "C" fn(
1235 me: *mut ::std::os::raw::c_void,
1236 keyNames: *mut ICapeArrayString,
1237 ) -> CapeResult,
1238 >,
1239 pub getSubKey: ::std::option::Option<
1240 unsafe extern "C" fn(
1241 me: *mut ::std::os::raw::c_void,
1242 keyName: *const CapeCharacter,
1243 key: *mut *mut _ICapeRegistryKey,
1244 ) -> CapeResult,
1245 >,
1246 pub isAllUsers: ::std::option::Option<
1247 unsafe extern "C" fn(
1248 me: *mut ::std::os::raw::c_void,
1249 valueName: *const CapeCharacter,
1250 allUsers: *mut CapeBoolean,
1251 ) -> CapeResult,
1252 >,
1253}
1254#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1255const _: () = {
1256 ["Size of ICapeRegistryKey_VTable"][::std::mem::size_of::<ICapeRegistryKey_VTable>() - 80usize];
1257 ["Alignment of ICapeRegistryKey_VTable"]
1258 [::std::mem::align_of::<ICapeRegistryKey_VTable>() - 8usize];
1259 ["Offset of field: ICapeRegistryKey_VTable::base"]
1260 [::std::mem::offset_of!(ICapeRegistryKey_VTable, base) - 0usize];
1261 ["Offset of field: ICapeRegistryKey_VTable::getValues"]
1262 [::std::mem::offset_of!(ICapeRegistryKey_VTable, getValues) - 16usize];
1263 ["Offset of field: ICapeRegistryKey_VTable::getValueType"]
1264 [::std::mem::offset_of!(ICapeRegistryKey_VTable, getValueType) - 24usize];
1265 ["Offset of field: ICapeRegistryKey_VTable::getStringValue"]
1266 [::std::mem::offset_of!(ICapeRegistryKey_VTable, getStringValue) - 32usize];
1267 ["Offset of field: ICapeRegistryKey_VTable::getIntegerValue"]
1268 [::std::mem::offset_of!(ICapeRegistryKey_VTable, getIntegerValue) - 40usize];
1269 ["Offset of field: ICapeRegistryKey_VTable::getUUIDValue"]
1270 [::std::mem::offset_of!(ICapeRegistryKey_VTable, getUUIDValue) - 48usize];
1271 ["Offset of field: ICapeRegistryKey_VTable::getKeys"]
1272 [::std::mem::offset_of!(ICapeRegistryKey_VTable, getKeys) - 56usize];
1273 ["Offset of field: ICapeRegistryKey_VTable::getSubKey"]
1274 [::std::mem::offset_of!(ICapeRegistryKey_VTable, getSubKey) - 64usize];
1275 ["Offset of field: ICapeRegistryKey_VTable::isAllUsers"]
1276 [::std::mem::offset_of!(ICapeRegistryKey_VTable, isAllUsers) - 72usize];
1277};
1278#[repr(C)]
1279#[derive(Debug, Copy, Clone)]
1280pub struct _ICapeRegistryKey {
1281 #[doc = "!<object pointer"]
1282 pub me: *mut ::std::os::raw::c_void,
1283 #[doc = "!<function pointer table"]
1284 pub vTbl: *mut ICapeRegistryKey_VTable,
1285}
1286#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1287const _: () = {
1288 ["Size of _ICapeRegistryKey"][::std::mem::size_of::<_ICapeRegistryKey>() - 16usize];
1289 ["Alignment of _ICapeRegistryKey"][::std::mem::align_of::<_ICapeRegistryKey>() - 8usize];
1290 ["Offset of field: _ICapeRegistryKey::me"]
1291 [::std::mem::offset_of!(_ICapeRegistryKey, me) - 0usize];
1292 ["Offset of field: _ICapeRegistryKey::vTbl"]
1293 [::std::mem::offset_of!(_ICapeRegistryKey, vTbl) - 8usize];
1294};
1295pub type ICapeRegistryKey = _ICapeRegistryKey;
1296#[repr(C)]
1297#[derive(Debug, Copy, Clone)]
1298pub struct ICapeRegistryKeyWriter_VTable {
1299 pub base: ICapeRegistryKey_VTable,
1300 pub createSubKey: ::std::option::Option<
1301 unsafe extern "C" fn(
1302 me: *mut ::std::os::raw::c_void,
1303 keyName: *const CapeCharacter,
1304 key: *mut *mut _ICapeRegistryKeyWriter,
1305 ) -> CapeResult,
1306 >,
1307 pub deleteSubKey: ::std::option::Option<
1308 unsafe extern "C" fn(
1309 me: *mut ::std::os::raw::c_void,
1310 keyName: *const CapeCharacter,
1311 ) -> CapeResult,
1312 >,
1313 pub deleteValue: ::std::option::Option<
1314 unsafe extern "C" fn(
1315 me: *mut ::std::os::raw::c_void,
1316 keyName: *const CapeCharacter,
1317 valueName: *const CapeCharacter,
1318 ) -> CapeResult,
1319 >,
1320 pub putStringValue: ::std::option::Option<
1321 unsafe extern "C" fn(
1322 me: *mut ::std::os::raw::c_void,
1323 valueName: *const CapeCharacter,
1324 value: *const CapeCharacter,
1325 ) -> CapeResult,
1326 >,
1327 pub putIntegerValue: ::std::option::Option<
1328 unsafe extern "C" fn(
1329 me: *mut ::std::os::raw::c_void,
1330 valueName: *const CapeCharacter,
1331 value: CapeInteger,
1332 ) -> CapeResult,
1333 >,
1334 pub putUUIDValue: ::std::option::Option<
1335 unsafe extern "C" fn(
1336 me: *mut ::std::os::raw::c_void,
1337 valueName: *const CapeCharacter,
1338 value: *const CapeUUID,
1339 ) -> CapeResult,
1340 >,
1341 pub putEmptyValue: ::std::option::Option<
1342 unsafe extern "C" fn(
1343 me: *mut ::std::os::raw::c_void,
1344 valueName: *const CapeCharacter,
1345 ) -> CapeResult,
1346 >,
1347}
1348#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1349const _: () = {
1350 ["Size of ICapeRegistryKeyWriter_VTable"]
1351 [::std::mem::size_of::<ICapeRegistryKeyWriter_VTable>() - 136usize];
1352 ["Alignment of ICapeRegistryKeyWriter_VTable"]
1353 [::std::mem::align_of::<ICapeRegistryKeyWriter_VTable>() - 8usize];
1354 ["Offset of field: ICapeRegistryKeyWriter_VTable::base"]
1355 [::std::mem::offset_of!(ICapeRegistryKeyWriter_VTable, base) - 0usize];
1356 ["Offset of field: ICapeRegistryKeyWriter_VTable::createSubKey"]
1357 [::std::mem::offset_of!(ICapeRegistryKeyWriter_VTable, createSubKey) - 80usize];
1358 ["Offset of field: ICapeRegistryKeyWriter_VTable::deleteSubKey"]
1359 [::std::mem::offset_of!(ICapeRegistryKeyWriter_VTable, deleteSubKey) - 88usize];
1360 ["Offset of field: ICapeRegistryKeyWriter_VTable::deleteValue"]
1361 [::std::mem::offset_of!(ICapeRegistryKeyWriter_VTable, deleteValue) - 96usize];
1362 ["Offset of field: ICapeRegistryKeyWriter_VTable::putStringValue"]
1363 [::std::mem::offset_of!(ICapeRegistryKeyWriter_VTable, putStringValue) - 104usize];
1364 ["Offset of field: ICapeRegistryKeyWriter_VTable::putIntegerValue"]
1365 [::std::mem::offset_of!(ICapeRegistryKeyWriter_VTable, putIntegerValue) - 112usize];
1366 ["Offset of field: ICapeRegistryKeyWriter_VTable::putUUIDValue"]
1367 [::std::mem::offset_of!(ICapeRegistryKeyWriter_VTable, putUUIDValue) - 120usize];
1368 ["Offset of field: ICapeRegistryKeyWriter_VTable::putEmptyValue"]
1369 [::std::mem::offset_of!(ICapeRegistryKeyWriter_VTable, putEmptyValue) - 128usize];
1370};
1371#[repr(C)]
1372#[derive(Debug, Copy, Clone)]
1373pub struct _ICapeRegistryKeyWriter {
1374 #[doc = "!<object pointer"]
1375 pub me: *mut ::std::os::raw::c_void,
1376 #[doc = "!<function pointer table"]
1377 pub vTbl: *mut ICapeRegistryKeyWriter_VTable,
1378}
1379#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1380const _: () = {
1381 ["Size of _ICapeRegistryKeyWriter"][::std::mem::size_of::<_ICapeRegistryKeyWriter>() - 16usize];
1382 ["Alignment of _ICapeRegistryKeyWriter"]
1383 [::std::mem::align_of::<_ICapeRegistryKeyWriter>() - 8usize];
1384 ["Offset of field: _ICapeRegistryKeyWriter::me"]
1385 [::std::mem::offset_of!(_ICapeRegistryKeyWriter, me) - 0usize];
1386 ["Offset of field: _ICapeRegistryKeyWriter::vTbl"]
1387 [::std::mem::offset_of!(_ICapeRegistryKeyWriter, vTbl) - 8usize];
1388};
1389pub type ICapeRegistryKeyWriter = _ICapeRegistryKeyWriter;
1390#[repr(C)]
1391#[derive(Debug, Copy, Clone)]
1392pub struct ICapePMCRegistrar_VTable {
1393 pub base: ICobiaBase_VTable,
1394 pub putName: ::std::option::Option<
1395 unsafe extern "C" fn(
1396 me: *mut ::std::os::raw::c_void,
1397 name: *const CapeCharacter,
1398 ) -> CapeResult,
1399 >,
1400 pub putDescription: ::std::option::Option<
1401 unsafe extern "C" fn(
1402 me: *mut ::std::os::raw::c_void,
1403 description: *const CapeCharacter,
1404 ) -> CapeResult,
1405 >,
1406 pub putCapeVersion: ::std::option::Option<
1407 unsafe extern "C" fn(
1408 me: *mut ::std::os::raw::c_void,
1409 capeVersion: *const CapeCharacter,
1410 ) -> CapeResult,
1411 >,
1412 pub putComponentVersion: ::std::option::Option<
1413 unsafe extern "C" fn(
1414 me: *mut ::std::os::raw::c_void,
1415 componentVersion: *const CapeCharacter,
1416 ) -> CapeResult,
1417 >,
1418 pub putVendorURL: ::std::option::Option<
1419 unsafe extern "C" fn(
1420 me: *mut ::std::os::raw::c_void,
1421 vendorURL: *const CapeCharacter,
1422 ) -> CapeResult,
1423 >,
1424 pub putHelpURL: ::std::option::Option<
1425 unsafe extern "C" fn(
1426 me: *mut ::std::os::raw::c_void,
1427 helpURL: *const CapeCharacter,
1428 ) -> CapeResult,
1429 >,
1430 pub putAbout: ::std::option::Option<
1431 unsafe extern "C" fn(
1432 me: *mut ::std::os::raw::c_void,
1433 about: *const CapeCharacter,
1434 ) -> CapeResult,
1435 >,
1436 pub putUUID: ::std::option::Option<
1437 unsafe extern "C" fn(me: *mut ::std::os::raw::c_void, uuid: *const CapeUUID) -> CapeResult,
1438 >,
1439 pub putProgId: ::std::option::Option<
1440 unsafe extern "C" fn(
1441 me: *mut ::std::os::raw::c_void,
1442 progId: *const CapeCharacter,
1443 ) -> CapeResult,
1444 >,
1445 pub addCatID: ::std::option::Option<
1446 unsafe extern "C" fn(me: *mut ::std::os::raw::c_void, catID: *const CapeUUID) -> CapeResult,
1447 >,
1448 pub putFlags: ::std::option::Option<
1449 unsafe extern "C" fn(
1450 me: *mut ::std::os::raw::c_void,
1451 flags: CapePMCRegistrationFlags,
1452 ) -> CapeResult,
1453 >,
1454 pub addLocation: ::std::option::Option<
1455 unsafe extern "C" fn(
1456 me: *mut ::std::os::raw::c_void,
1457 serviceType: CapePMCServiceType,
1458 location: *const CapeCharacter,
1459 ) -> CapeResult,
1460 >,
1461 pub commit:
1462 ::std::option::Option<unsafe extern "C" fn(me: *mut ::std::os::raw::c_void) -> CapeResult>,
1463 pub putVersionIndependentProgId: ::std::option::Option<
1464 unsafe extern "C" fn(
1465 me: *mut ::std::os::raw::c_void,
1466 versionIndependentProgId: *const CapeCharacter,
1467 ) -> CapeResult,
1468 >,
1469}
1470#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1471const _: () = {
1472 ["Size of ICapePMCRegistrar_VTable"]
1473 [::std::mem::size_of::<ICapePMCRegistrar_VTable>() - 128usize];
1474 ["Alignment of ICapePMCRegistrar_VTable"]
1475 [::std::mem::align_of::<ICapePMCRegistrar_VTable>() - 8usize];
1476 ["Offset of field: ICapePMCRegistrar_VTable::base"]
1477 [::std::mem::offset_of!(ICapePMCRegistrar_VTable, base) - 0usize];
1478 ["Offset of field: ICapePMCRegistrar_VTable::putName"]
1479 [::std::mem::offset_of!(ICapePMCRegistrar_VTable, putName) - 16usize];
1480 ["Offset of field: ICapePMCRegistrar_VTable::putDescription"]
1481 [::std::mem::offset_of!(ICapePMCRegistrar_VTable, putDescription) - 24usize];
1482 ["Offset of field: ICapePMCRegistrar_VTable::putCapeVersion"]
1483 [::std::mem::offset_of!(ICapePMCRegistrar_VTable, putCapeVersion) - 32usize];
1484 ["Offset of field: ICapePMCRegistrar_VTable::putComponentVersion"]
1485 [::std::mem::offset_of!(ICapePMCRegistrar_VTable, putComponentVersion) - 40usize];
1486 ["Offset of field: ICapePMCRegistrar_VTable::putVendorURL"]
1487 [::std::mem::offset_of!(ICapePMCRegistrar_VTable, putVendorURL) - 48usize];
1488 ["Offset of field: ICapePMCRegistrar_VTable::putHelpURL"]
1489 [::std::mem::offset_of!(ICapePMCRegistrar_VTable, putHelpURL) - 56usize];
1490 ["Offset of field: ICapePMCRegistrar_VTable::putAbout"]
1491 [::std::mem::offset_of!(ICapePMCRegistrar_VTable, putAbout) - 64usize];
1492 ["Offset of field: ICapePMCRegistrar_VTable::putUUID"]
1493 [::std::mem::offset_of!(ICapePMCRegistrar_VTable, putUUID) - 72usize];
1494 ["Offset of field: ICapePMCRegistrar_VTable::putProgId"]
1495 [::std::mem::offset_of!(ICapePMCRegistrar_VTable, putProgId) - 80usize];
1496 ["Offset of field: ICapePMCRegistrar_VTable::addCatID"]
1497 [::std::mem::offset_of!(ICapePMCRegistrar_VTable, addCatID) - 88usize];
1498 ["Offset of field: ICapePMCRegistrar_VTable::putFlags"]
1499 [::std::mem::offset_of!(ICapePMCRegistrar_VTable, putFlags) - 96usize];
1500 ["Offset of field: ICapePMCRegistrar_VTable::addLocation"]
1501 [::std::mem::offset_of!(ICapePMCRegistrar_VTable, addLocation) - 104usize];
1502 ["Offset of field: ICapePMCRegistrar_VTable::commit"]
1503 [::std::mem::offset_of!(ICapePMCRegistrar_VTable, commit) - 112usize];
1504 ["Offset of field: ICapePMCRegistrar_VTable::putVersionIndependentProgId"]
1505 [::std::mem::offset_of!(ICapePMCRegistrar_VTable, putVersionIndependentProgId) - 120usize];
1506};
1507#[repr(C)]
1508#[derive(Debug, Copy, Clone)]
1509pub struct ICapePMCRegistrar {
1510 #[doc = "!<object pointer"]
1511 pub me: *mut ::std::os::raw::c_void,
1512 #[doc = "!<function pointer table"]
1513 pub vTbl: *mut ICapePMCRegistrar_VTable,
1514}
1515#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1516const _: () = {
1517 ["Size of ICapePMCRegistrar"][::std::mem::size_of::<ICapePMCRegistrar>() - 16usize];
1518 ["Alignment of ICapePMCRegistrar"][::std::mem::align_of::<ICapePMCRegistrar>() - 8usize];
1519 ["Offset of field: ICapePMCRegistrar::me"]
1520 [::std::mem::offset_of!(ICapePMCRegistrar, me) - 0usize];
1521 ["Offset of field: ICapePMCRegistrar::vTbl"]
1522 [::std::mem::offset_of!(ICapePMCRegistrar, vTbl) - 8usize];
1523};
1524#[repr(C)]
1525#[derive(Debug, Copy, Clone)]
1526pub struct ICapeRegistryWriter_VTable {
1527 pub base: ICobiaBase_VTable,
1528 pub createKey: ::std::option::Option<
1529 unsafe extern "C" fn(
1530 me: *mut ::std::os::raw::c_void,
1531 keyName: *const CapeCharacter,
1532 key: *mut *mut ICapeRegistryKeyWriter,
1533 ) -> CapeResult,
1534 >,
1535 pub getKey: ::std::option::Option<
1536 unsafe extern "C" fn(
1537 me: *mut ::std::os::raw::c_void,
1538 keyName: *const CapeCharacter,
1539 key: *mut *mut ICapeRegistryKey,
1540 ) -> CapeResult,
1541 >,
1542 pub deleteKey: ::std::option::Option<
1543 unsafe extern "C" fn(
1544 me: *mut ::std::os::raw::c_void,
1545 keyName: *const CapeCharacter,
1546 ) -> CapeResult,
1547 >,
1548 pub deleteValue: ::std::option::Option<
1549 unsafe extern "C" fn(
1550 me: *mut ::std::os::raw::c_void,
1551 keyName: *const CapeCharacter,
1552 valueName: *const CapeCharacter,
1553 ) -> CapeResult,
1554 >,
1555 pub getPMCRegistrar: ::std::option::Option<
1556 unsafe extern "C" fn(
1557 me: *mut ::std::os::raw::c_void,
1558 registrar: *mut *mut ICapePMCRegistrar,
1559 ) -> CapeResult,
1560 >,
1561 pub unregisterPMC: ::std::option::Option<
1562 unsafe extern "C" fn(me: *mut ::std::os::raw::c_void, uuid: *const CapeUUID) -> CapeResult,
1563 >,
1564 pub unregisterPMCService: ::std::option::Option<
1565 unsafe extern "C" fn(
1566 me: *mut ::std::os::raw::c_void,
1567 uuid: *const CapeUUID,
1568 service: CapePMCServiceType,
1569 ) -> CapeResult,
1570 >,
1571 pub revert:
1572 ::std::option::Option<unsafe extern "C" fn(me: *mut ::std::os::raw::c_void) -> CapeResult>,
1573 pub commit:
1574 ::std::option::Option<unsafe extern "C" fn(me: *mut ::std::os::raw::c_void) -> CapeResult>,
1575 pub registerTypesFromIDL: ::std::option::Option<
1576 unsafe extern "C" fn(
1577 me: *mut ::std::os::raw::c_void,
1578 idlFiles: *mut ICapeArrayString,
1579 ) -> CapeResult,
1580 >,
1581 pub unregisterTypes: ::std::option::Option<
1582 unsafe extern "C" fn(
1583 me: *mut ::std::os::raw::c_void,
1584 libraryID: *const CapeUUID,
1585 ) -> CapeResult,
1586 >,
1587 pub registerProxyInterfaceProvider: ::std::option::Option<
1588 unsafe extern "C" fn(
1589 me: *mut ::std::os::raw::c_void,
1590 libraryID: *const CapeUUID,
1591 serviceType: CapePMCServiceType,
1592 location: *const CapeCharacter,
1593 ) -> CapeResult,
1594 >,
1595 pub unregisterProxyInterfaceProvider: ::std::option::Option<
1596 unsafe extern "C" fn(
1597 me: *mut ::std::os::raw::c_void,
1598 libraryID: *const CapeUUID,
1599 serviceType: CapePMCServiceType,
1600 ) -> CapeResult,
1601 >,
1602}
1603#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1604const _: () = {
1605 ["Size of ICapeRegistryWriter_VTable"]
1606 [::std::mem::size_of::<ICapeRegistryWriter_VTable>() - 120usize];
1607 ["Alignment of ICapeRegistryWriter_VTable"]
1608 [::std::mem::align_of::<ICapeRegistryWriter_VTable>() - 8usize];
1609 ["Offset of field: ICapeRegistryWriter_VTable::base"]
1610 [::std::mem::offset_of!(ICapeRegistryWriter_VTable, base) - 0usize];
1611 ["Offset of field: ICapeRegistryWriter_VTable::createKey"]
1612 [::std::mem::offset_of!(ICapeRegistryWriter_VTable, createKey) - 16usize];
1613 ["Offset of field: ICapeRegistryWriter_VTable::getKey"]
1614 [::std::mem::offset_of!(ICapeRegistryWriter_VTable, getKey) - 24usize];
1615 ["Offset of field: ICapeRegistryWriter_VTable::deleteKey"]
1616 [::std::mem::offset_of!(ICapeRegistryWriter_VTable, deleteKey) - 32usize];
1617 ["Offset of field: ICapeRegistryWriter_VTable::deleteValue"]
1618 [::std::mem::offset_of!(ICapeRegistryWriter_VTable, deleteValue) - 40usize];
1619 ["Offset of field: ICapeRegistryWriter_VTable::getPMCRegistrar"]
1620 [::std::mem::offset_of!(ICapeRegistryWriter_VTable, getPMCRegistrar) - 48usize];
1621 ["Offset of field: ICapeRegistryWriter_VTable::unregisterPMC"]
1622 [::std::mem::offset_of!(ICapeRegistryWriter_VTable, unregisterPMC) - 56usize];
1623 ["Offset of field: ICapeRegistryWriter_VTable::unregisterPMCService"]
1624 [::std::mem::offset_of!(ICapeRegistryWriter_VTable, unregisterPMCService) - 64usize];
1625 ["Offset of field: ICapeRegistryWriter_VTable::revert"]
1626 [::std::mem::offset_of!(ICapeRegistryWriter_VTable, revert) - 72usize];
1627 ["Offset of field: ICapeRegistryWriter_VTable::commit"]
1628 [::std::mem::offset_of!(ICapeRegistryWriter_VTable, commit) - 80usize];
1629 ["Offset of field: ICapeRegistryWriter_VTable::registerTypesFromIDL"]
1630 [::std::mem::offset_of!(ICapeRegistryWriter_VTable, registerTypesFromIDL) - 88usize];
1631 ["Offset of field: ICapeRegistryWriter_VTable::unregisterTypes"]
1632 [::std::mem::offset_of!(ICapeRegistryWriter_VTable, unregisterTypes) - 96usize];
1633 ["Offset of field: ICapeRegistryWriter_VTable::registerProxyInterfaceProvider"][::std::mem::offset_of!(
1634 ICapeRegistryWriter_VTable,
1635 registerProxyInterfaceProvider
1636 ) - 104usize];
1637 ["Offset of field: ICapeRegistryWriter_VTable::unregisterProxyInterfaceProvider"][::std::mem::offset_of!(
1638 ICapeRegistryWriter_VTable,
1639 unregisterProxyInterfaceProvider
1640 ) - 112usize];
1641};
1642#[repr(C)]
1643#[derive(Debug, Copy, Clone)]
1644pub struct ICapeRegistryWriter {
1645 #[doc = "!<object pointer"]
1646 pub me: *mut ::std::os::raw::c_void,
1647 #[doc = "!<function pointer table"]
1648 pub vTbl: *mut ICapeRegistryWriter_VTable,
1649}
1650#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1651const _: () = {
1652 ["Size of ICapeRegistryWriter"][::std::mem::size_of::<ICapeRegistryWriter>() - 16usize];
1653 ["Alignment of ICapeRegistryWriter"][::std::mem::align_of::<ICapeRegistryWriter>() - 8usize];
1654 ["Offset of field: ICapeRegistryWriter::me"]
1655 [::std::mem::offset_of!(ICapeRegistryWriter, me) - 0usize];
1656 ["Offset of field: ICapeRegistryWriter::vTbl"]
1657 [::std::mem::offset_of!(ICapeRegistryWriter, vTbl) - 8usize];
1658};
1659#[repr(C)]
1660#[derive(Debug, Copy, Clone)]
1661pub struct ICapePMCRegistrationDetails_VTable {
1662 pub base: ICapeInterface_VTable,
1663 pub getName: ::std::option::Option<
1664 unsafe extern "C" fn(me: *mut ::std::os::raw::c_void, name: *mut ICapeString) -> CapeResult,
1665 >,
1666 pub getDescription: ::std::option::Option<
1667 unsafe extern "C" fn(
1668 me: *mut ::std::os::raw::c_void,
1669 description: *mut ICapeString,
1670 ) -> CapeResult,
1671 >,
1672 pub getCapeVersion: ::std::option::Option<
1673 unsafe extern "C" fn(
1674 me: *mut ::std::os::raw::c_void,
1675 capeVersion: *mut ICapeString,
1676 ) -> CapeResult,
1677 >,
1678 pub getComponentVersion: ::std::option::Option<
1679 unsafe extern "C" fn(
1680 me: *mut ::std::os::raw::c_void,
1681 componentVersion: *mut ICapeString,
1682 ) -> CapeResult,
1683 >,
1684 pub getVendorURL: ::std::option::Option<
1685 unsafe extern "C" fn(
1686 me: *mut ::std::os::raw::c_void,
1687 vendorURL: *mut ICapeString,
1688 ) -> CapeResult,
1689 >,
1690 pub getHelpURL: ::std::option::Option<
1691 unsafe extern "C" fn(
1692 me: *mut ::std::os::raw::c_void,
1693 helpURL: *mut ICapeString,
1694 ) -> CapeResult,
1695 >,
1696 pub getAbout: ::std::option::Option<
1697 unsafe extern "C" fn(
1698 me: *mut ::std::os::raw::c_void,
1699 about: *mut ICapeString,
1700 ) -> CapeResult,
1701 >,
1702 pub getUUID: ::std::option::Option<
1703 unsafe extern "C" fn(me: *mut ::std::os::raw::c_void, uuid: *mut CapeUUID) -> CapeResult,
1704 >,
1705 pub getProgId: ::std::option::Option<
1706 unsafe extern "C" fn(
1707 me: *mut ::std::os::raw::c_void,
1708 progId: *mut ICapeString,
1709 ) -> CapeResult,
1710 >,
1711 pub getCatIDs: ::std::option::Option<
1712 unsafe extern "C" fn(
1713 me: *mut ::std::os::raw::c_void,
1714 catIDs: *mut ICapeArrayString,
1715 ) -> CapeResult,
1716 >,
1717 pub implementsCatID: ::std::option::Option<
1718 unsafe extern "C" fn(
1719 me: *mut ::std::os::raw::c_void,
1720 catID: *const CapeUUID,
1721 result: *mut CapeBoolean,
1722 ) -> CapeResult,
1723 >,
1724 pub getServiceTypes: ::std::option::Option<
1725 unsafe extern "C" fn(
1726 me: *mut ::std::os::raw::c_void,
1727 serviceTypes: *mut ICapeArrayEnumeration,
1728 ) -> CapeResult,
1729 >,
1730 pub getLocation: ::std::option::Option<
1731 unsafe extern "C" fn(
1732 me: *mut ::std::os::raw::c_void,
1733 serviceType: CapePMCServiceType,
1734 location: *mut ICapeString,
1735 ) -> CapeResult,
1736 >,
1737 pub registeredForAllUsers: ::std::option::Option<
1738 unsafe extern "C" fn(
1739 me: *mut ::std::os::raw::c_void,
1740 serviceType: CapePMCServiceType,
1741 forAllUsers: *mut CapeBoolean,
1742 ) -> CapeResult,
1743 >,
1744 pub getFlags: ::std::option::Option<
1745 unsafe extern "C" fn(
1746 me: *mut ::std::os::raw::c_void,
1747 flags: *mut CapePMCRegistrationFlags,
1748 ) -> CapeResult,
1749 >,
1750 pub createInstance: ::std::option::Option<
1751 unsafe extern "C" fn(
1752 me: *mut ::std::os::raw::c_void,
1753 flags: CapePMCCreationFlags,
1754 instance: *mut *mut ICapeInterface,
1755 ) -> CapeResult,
1756 >,
1757 pub getVersionIndependentProgId: ::std::option::Option<
1758 unsafe extern "C" fn(
1759 me: *mut ::std::os::raw::c_void,
1760 versionIndependentProgId: *mut ICapeString,
1761 ) -> CapeResult,
1762 >,
1763}
1764#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1765const _: () = {
1766 ["Size of ICapePMCRegistrationDetails_VTable"]
1767 [::std::mem::size_of::<ICapePMCRegistrationDetails_VTable>() - 168usize];
1768 ["Alignment of ICapePMCRegistrationDetails_VTable"]
1769 [::std::mem::align_of::<ICapePMCRegistrationDetails_VTable>() - 8usize];
1770 ["Offset of field: ICapePMCRegistrationDetails_VTable::base"]
1771 [::std::mem::offset_of!(ICapePMCRegistrationDetails_VTable, base) - 0usize];
1772 ["Offset of field: ICapePMCRegistrationDetails_VTable::getName"]
1773 [::std::mem::offset_of!(ICapePMCRegistrationDetails_VTable, getName) - 32usize];
1774 ["Offset of field: ICapePMCRegistrationDetails_VTable::getDescription"]
1775 [::std::mem::offset_of!(ICapePMCRegistrationDetails_VTable, getDescription) - 40usize];
1776 ["Offset of field: ICapePMCRegistrationDetails_VTable::getCapeVersion"]
1777 [::std::mem::offset_of!(ICapePMCRegistrationDetails_VTable, getCapeVersion) - 48usize];
1778 ["Offset of field: ICapePMCRegistrationDetails_VTable::getComponentVersion"]
1779 [::std::mem::offset_of!(ICapePMCRegistrationDetails_VTable, getComponentVersion) - 56usize];
1780 ["Offset of field: ICapePMCRegistrationDetails_VTable::getVendorURL"]
1781 [::std::mem::offset_of!(ICapePMCRegistrationDetails_VTable, getVendorURL) - 64usize];
1782 ["Offset of field: ICapePMCRegistrationDetails_VTable::getHelpURL"]
1783 [::std::mem::offset_of!(ICapePMCRegistrationDetails_VTable, getHelpURL) - 72usize];
1784 ["Offset of field: ICapePMCRegistrationDetails_VTable::getAbout"]
1785 [::std::mem::offset_of!(ICapePMCRegistrationDetails_VTable, getAbout) - 80usize];
1786 ["Offset of field: ICapePMCRegistrationDetails_VTable::getUUID"]
1787 [::std::mem::offset_of!(ICapePMCRegistrationDetails_VTable, getUUID) - 88usize];
1788 ["Offset of field: ICapePMCRegistrationDetails_VTable::getProgId"]
1789 [::std::mem::offset_of!(ICapePMCRegistrationDetails_VTable, getProgId) - 96usize];
1790 ["Offset of field: ICapePMCRegistrationDetails_VTable::getCatIDs"]
1791 [::std::mem::offset_of!(ICapePMCRegistrationDetails_VTable, getCatIDs) - 104usize];
1792 ["Offset of field: ICapePMCRegistrationDetails_VTable::implementsCatID"]
1793 [::std::mem::offset_of!(ICapePMCRegistrationDetails_VTable, implementsCatID) - 112usize];
1794 ["Offset of field: ICapePMCRegistrationDetails_VTable::getServiceTypes"]
1795 [::std::mem::offset_of!(ICapePMCRegistrationDetails_VTable, getServiceTypes) - 120usize];
1796 ["Offset of field: ICapePMCRegistrationDetails_VTable::getLocation"]
1797 [::std::mem::offset_of!(ICapePMCRegistrationDetails_VTable, getLocation) - 128usize];
1798 ["Offset of field: ICapePMCRegistrationDetails_VTable::registeredForAllUsers"][::std::mem::offset_of!(
1799 ICapePMCRegistrationDetails_VTable,
1800 registeredForAllUsers
1801 ) - 136usize];
1802 ["Offset of field: ICapePMCRegistrationDetails_VTable::getFlags"]
1803 [::std::mem::offset_of!(ICapePMCRegistrationDetails_VTable, getFlags) - 144usize];
1804 ["Offset of field: ICapePMCRegistrationDetails_VTable::createInstance"]
1805 [::std::mem::offset_of!(ICapePMCRegistrationDetails_VTable, createInstance) - 152usize];
1806 ["Offset of field: ICapePMCRegistrationDetails_VTable::getVersionIndependentProgId"][::std::mem::offset_of!(
1807 ICapePMCRegistrationDetails_VTable,
1808 getVersionIndependentProgId
1809 )
1810 - 160usize];
1811};
1812#[repr(C)]
1813#[derive(Debug, Copy, Clone)]
1814pub struct ICapePMCRegistrationDetails {
1815 #[doc = "!<object pointer"]
1816 pub me: *mut ::std::os::raw::c_void,
1817 #[doc = "!<function pointer table"]
1818 pub vTbl: *mut ICapePMCRegistrationDetails_VTable,
1819}
1820#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1821const _: () = {
1822 ["Size of ICapePMCRegistrationDetails"]
1823 [::std::mem::size_of::<ICapePMCRegistrationDetails>() - 16usize];
1824 ["Alignment of ICapePMCRegistrationDetails"]
1825 [::std::mem::align_of::<ICapePMCRegistrationDetails>() - 8usize];
1826 ["Offset of field: ICapePMCRegistrationDetails::me"]
1827 [::std::mem::offset_of!(ICapePMCRegistrationDetails, me) - 0usize];
1828 ["Offset of field: ICapePMCRegistrationDetails::vTbl"]
1829 [::std::mem::offset_of!(ICapePMCRegistrationDetails, vTbl) - 8usize];
1830};
1831#[repr(C)]
1832#[derive(Debug, Copy, Clone)]
1833pub struct ICapePMCEnumerator_VTable {
1834 pub base: ICobiaBase_VTable,
1835 pub getPMCbyUUID: ::std::option::Option<
1836 unsafe extern "C" fn(
1837 me: *mut ::std::os::raw::c_void,
1838 uuid: *const CapeUUID,
1839 PMCdetails: *mut *mut ICapePMCRegistrationDetails,
1840 ) -> CapeResult,
1841 >,
1842 pub getPMCbyProgId: ::std::option::Option<
1843 unsafe extern "C" fn(
1844 me: *mut ::std::os::raw::c_void,
1845 progId: *const CapeCharacter,
1846 PMCdetails: *mut *mut ICapePMCRegistrationDetails,
1847 ) -> CapeResult,
1848 >,
1849 pub getPMCsByCategory: ::std::option::Option<
1850 unsafe extern "C" fn(
1851 me: *mut ::std::os::raw::c_void,
1852 catIDs: *const CapeUUID,
1853 nCatID: CapeSize,
1854 PMCs: *mut *mut ICobiaCollection,
1855 ) -> CapeResult,
1856 >,
1857 pub getAllPMCs: ::std::option::Option<
1858 unsafe extern "C" fn(
1859 me: *mut ::std::os::raw::c_void,
1860 PMCs: *mut *mut ICobiaCollection,
1861 ) -> CapeResult,
1862 >,
1863}
1864#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1865const _: () = {
1866 ["Size of ICapePMCEnumerator_VTable"]
1867 [::std::mem::size_of::<ICapePMCEnumerator_VTable>() - 48usize];
1868 ["Alignment of ICapePMCEnumerator_VTable"]
1869 [::std::mem::align_of::<ICapePMCEnumerator_VTable>() - 8usize];
1870 ["Offset of field: ICapePMCEnumerator_VTable::base"]
1871 [::std::mem::offset_of!(ICapePMCEnumerator_VTable, base) - 0usize];
1872 ["Offset of field: ICapePMCEnumerator_VTable::getPMCbyUUID"]
1873 [::std::mem::offset_of!(ICapePMCEnumerator_VTable, getPMCbyUUID) - 16usize];
1874 ["Offset of field: ICapePMCEnumerator_VTable::getPMCbyProgId"]
1875 [::std::mem::offset_of!(ICapePMCEnumerator_VTable, getPMCbyProgId) - 24usize];
1876 ["Offset of field: ICapePMCEnumerator_VTable::getPMCsByCategory"]
1877 [::std::mem::offset_of!(ICapePMCEnumerator_VTable, getPMCsByCategory) - 32usize];
1878 ["Offset of field: ICapePMCEnumerator_VTable::getAllPMCs"]
1879 [::std::mem::offset_of!(ICapePMCEnumerator_VTable, getAllPMCs) - 40usize];
1880};
1881#[repr(C)]
1882#[derive(Debug, Copy, Clone)]
1883pub struct ICapePMCEnumerator {
1884 #[doc = "!<object pointer"]
1885 pub me: *mut ::std::os::raw::c_void,
1886 #[doc = "!<function pointer table"]
1887 pub vTbl: *mut ICapePMCEnumerator_VTable,
1888}
1889#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1890const _: () = {
1891 ["Size of ICapePMCEnumerator"][::std::mem::size_of::<ICapePMCEnumerator>() - 16usize];
1892 ["Alignment of ICapePMCEnumerator"][::std::mem::align_of::<ICapePMCEnumerator>() - 8usize];
1893 ["Offset of field: ICapePMCEnumerator::me"]
1894 [::std::mem::offset_of!(ICapePMCEnumerator, me) - 0usize];
1895 ["Offset of field: ICapePMCEnumerator::vTbl"]
1896 [::std::mem::offset_of!(ICapePMCEnumerator, vTbl) - 8usize];
1897};
1898#[repr(C)]
1899#[derive(Debug, Copy, Clone)]
1900pub struct ICapeLibraryDetails_VTable {
1901 pub base: ICapeInterface_VTable,
1902 pub getName: ::std::option::Option<
1903 unsafe extern "C" fn(me: *mut ::std::os::raw::c_void, name: *mut ICapeString) -> CapeResult,
1904 >,
1905 pub getUUID: ::std::option::Option<
1906 unsafe extern "C" fn(me: *mut ::std::os::raw::c_void, uuid: *mut CapeUUID) -> CapeResult,
1907 >,
1908 pub getLibraryVersion: ::std::option::Option<
1909 unsafe extern "C" fn(
1910 me: *mut ::std::os::raw::c_void,
1911 libraryVersion: *mut ICapeString,
1912 ) -> CapeResult,
1913 >,
1914 pub getLibraryPath: ::std::option::Option<
1915 unsafe extern "C" fn(me: *mut ::std::os::raw::c_void, path: *mut ICapeString) -> CapeResult,
1916 >,
1917 pub getProxyInterfaceProviderLocation: ::std::option::Option<
1918 unsafe extern "C" fn(
1919 me: *mut ::std::os::raw::c_void,
1920 service: CapePMCServiceType,
1921 loc: *mut ICapeString,
1922 ) -> CapeResult,
1923 >,
1924}
1925#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1926const _: () = {
1927 ["Size of ICapeLibraryDetails_VTable"]
1928 [::std::mem::size_of::<ICapeLibraryDetails_VTable>() - 72usize];
1929 ["Alignment of ICapeLibraryDetails_VTable"]
1930 [::std::mem::align_of::<ICapeLibraryDetails_VTable>() - 8usize];
1931 ["Offset of field: ICapeLibraryDetails_VTable::base"]
1932 [::std::mem::offset_of!(ICapeLibraryDetails_VTable, base) - 0usize];
1933 ["Offset of field: ICapeLibraryDetails_VTable::getName"]
1934 [::std::mem::offset_of!(ICapeLibraryDetails_VTable, getName) - 32usize];
1935 ["Offset of field: ICapeLibraryDetails_VTable::getUUID"]
1936 [::std::mem::offset_of!(ICapeLibraryDetails_VTable, getUUID) - 40usize];
1937 ["Offset of field: ICapeLibraryDetails_VTable::getLibraryVersion"]
1938 [::std::mem::offset_of!(ICapeLibraryDetails_VTable, getLibraryVersion) - 48usize];
1939 ["Offset of field: ICapeLibraryDetails_VTable::getLibraryPath"]
1940 [::std::mem::offset_of!(ICapeLibraryDetails_VTable, getLibraryPath) - 56usize];
1941 ["Offset of field: ICapeLibraryDetails_VTable::getProxyInterfaceProviderLocation"][::std::mem::offset_of!(
1942 ICapeLibraryDetails_VTable,
1943 getProxyInterfaceProviderLocation
1944 ) - 64usize];
1945};
1946#[repr(C)]
1947#[derive(Debug, Copy, Clone)]
1948pub struct ICapeLibraryDetails {
1949 #[doc = "!<object pointer"]
1950 pub me: *mut ::std::os::raw::c_void,
1951 #[doc = "!<function pointer table"]
1952 pub vTbl: *mut ICapeLibraryDetails_VTable,
1953}
1954#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1955const _: () = {
1956 ["Size of ICapeLibraryDetails"][::std::mem::size_of::<ICapeLibraryDetails>() - 16usize];
1957 ["Alignment of ICapeLibraryDetails"][::std::mem::align_of::<ICapeLibraryDetails>() - 8usize];
1958 ["Offset of field: ICapeLibraryDetails::me"]
1959 [::std::mem::offset_of!(ICapeLibraryDetails, me) - 0usize];
1960 ["Offset of field: ICapeLibraryDetails::vTbl"]
1961 [::std::mem::offset_of!(ICapeLibraryDetails, vTbl) - 8usize];
1962};
1963#[repr(C)]
1964#[derive(Debug, Copy, Clone)]
1965pub struct ICapeLibraryEnumerator_VTable {
1966 pub base: ICobiaBase_VTable,
1967 pub getLibraryByUUID: ::std::option::Option<
1968 unsafe extern "C" fn(
1969 me: *mut ::std::os::raw::c_void,
1970 uuid: *const CapeUUID,
1971 libraryDetails: *mut *mut ICapeLibraryDetails,
1972 ) -> CapeResult,
1973 >,
1974 pub getLibraryByName: ::std::option::Option<
1975 unsafe extern "C" fn(
1976 me: *mut ::std::os::raw::c_void,
1977 libName: *const CapeCharacter,
1978 libraryDetails: *mut *mut ICapeLibraryDetails,
1979 ) -> CapeResult,
1980 >,
1981 pub getAllLibraries: ::std::option::Option<
1982 unsafe extern "C" fn(
1983 me: *mut ::std::os::raw::c_void,
1984 libraries: *mut *mut ICobiaCollection,
1985 ) -> CapeResult,
1986 >,
1987 pub getLibraryByInterfaceUUID: ::std::option::Option<
1988 unsafe extern "C" fn(
1989 me: *mut ::std::os::raw::c_void,
1990 uuid: *const CapeUUID,
1991 libraryDetails: *mut *mut ICapeLibraryDetails,
1992 ) -> CapeResult,
1993 >,
1994}
1995#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1996const _: () = {
1997 ["Size of ICapeLibraryEnumerator_VTable"]
1998 [::std::mem::size_of::<ICapeLibraryEnumerator_VTable>() - 48usize];
1999 ["Alignment of ICapeLibraryEnumerator_VTable"]
2000 [::std::mem::align_of::<ICapeLibraryEnumerator_VTable>() - 8usize];
2001 ["Offset of field: ICapeLibraryEnumerator_VTable::base"]
2002 [::std::mem::offset_of!(ICapeLibraryEnumerator_VTable, base) - 0usize];
2003 ["Offset of field: ICapeLibraryEnumerator_VTable::getLibraryByUUID"]
2004 [::std::mem::offset_of!(ICapeLibraryEnumerator_VTable, getLibraryByUUID) - 16usize];
2005 ["Offset of field: ICapeLibraryEnumerator_VTable::getLibraryByName"]
2006 [::std::mem::offset_of!(ICapeLibraryEnumerator_VTable, getLibraryByName) - 24usize];
2007 ["Offset of field: ICapeLibraryEnumerator_VTable::getAllLibraries"]
2008 [::std::mem::offset_of!(ICapeLibraryEnumerator_VTable, getAllLibraries) - 32usize];
2009 ["Offset of field: ICapeLibraryEnumerator_VTable::getLibraryByInterfaceUUID"][::std::mem::offset_of!(
2010 ICapeLibraryEnumerator_VTable,
2011 getLibraryByInterfaceUUID
2012 ) - 40usize];
2013};
2014#[repr(C)]
2015#[derive(Debug, Copy, Clone)]
2016pub struct ICapeLibraryEnumerator {
2017 #[doc = "!<object pointer"]
2018 pub me: *mut ::std::os::raw::c_void,
2019 #[doc = "!<function pointer table"]
2020 pub vTbl: *mut ICapeLibraryEnumerator_VTable,
2021}
2022#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2023const _: () = {
2024 ["Size of ICapeLibraryEnumerator"][::std::mem::size_of::<ICapeLibraryEnumerator>() - 16usize];
2025 ["Alignment of ICapeLibraryEnumerator"]
2026 [::std::mem::align_of::<ICapeLibraryEnumerator>() - 8usize];
2027 ["Offset of field: ICapeLibraryEnumerator::me"]
2028 [::std::mem::offset_of!(ICapeLibraryEnumerator, me) - 0usize];
2029 ["Offset of field: ICapeLibraryEnumerator::vTbl"]
2030 [::std::mem::offset_of!(ICapeLibraryEnumerator, vTbl) - 8usize];
2031};
2032unsafe extern "C" {
2033 pub static ICapePMCRegistrationDetails_UUID: CapeUUID;
2034}
2035unsafe extern "C" {
2036 pub static ICapeLibraryDetails_UUID: CapeUUID;
2037}
2038pub type CAPESTRINGFUNC =
2039 ::std::option::Option<unsafe extern "C" fn(arg1: *mut ICapeString) -> CapeResult>;
2040pub type CAPEUUIDFUNCVOID = ::std::option::Option<unsafe extern "C" fn() -> CapeUUID>;
2041pub type CAPESTRINGFUNCCAPERESULT = ::std::option::Option<
2042 unsafe extern "C" fn(errorCode: CapeResult, arg1: *mut ICapeString) -> CapeResult,
2043>;
2044pub type CAPESTRINGFUNCUUID = ::std::option::Option<
2045 unsafe extern "C" fn(errorCode: *const CapeUUID, arg1: *mut ICapeString) -> CapeResult,
2046>;
2047pub type CAPEGETREGISTRYKEY = ::std::option::Option<
2048 unsafe extern "C" fn(
2049 keyName: *const CapeCharacter,
2050 key: *mut *mut ICapeRegistryKey,
2051 ) -> CapeResult,
2052>;
2053pub type CAPEGETREGISTRYWRITER = ::std::option::Option<
2054 unsafe extern "C" fn(allUsers: bool, writer: *mut *mut ICapeRegistryWriter) -> CapeResult,
2055>;
2056pub type CAPEGETPMCENUMERATOR = ::std::option::Option<
2057 unsafe extern "C" fn(pmcEnumerator: *mut *mut ICapePMCEnumerator) -> CapeResult,
2058>;
2059pub type CAPEGETLIBRARYENUMERATOR = ::std::option::Option<
2060 unsafe extern "C" fn(libraryEnumerator: *mut *mut ICapeLibraryEnumerator) -> CapeResult,
2061>;
2062pub type CAPEUUIDFROMSTRING = ::std::option::Option<
2063 unsafe extern "C" fn(str_: *const COBIACHAR, uuid: *mut CapeUUID) -> CapeResult,
2064>;
2065pub type COBIACREATEPMCINSTANCE = ::std::option::Option<
2066 unsafe extern "C" fn(
2067 uuid: *const CapeUUID,
2068 flags: CapePMCCreationFlags,
2069 instance: *mut *mut ICapeInterface,
2070 ) -> CapeResult,
2071>;
2072pub type COBIAGETDATACLASSFACTORY =
2073 ::std::option::Option<unsafe extern "C" fn() -> *mut ICobiaDataClassFactory>;
2074pub type COBIADEPERSISTFROMTRANSITIONFORMAT = ::std::option::Option<
2075 unsafe extern "C" fn(
2076 reader: *mut ICapeInterface,
2077 transitionFormat: *mut *mut ICapeInterface,
2078 majorVersion: CapeInteger,
2079 minorVersion: CapeInteger,
2080 ) -> CapeBoolean,
2081>;
2082pub type COBIADEPERSISTPMCFROMTRANSITIONFORMAT = ::std::option::Option<
2083 unsafe extern "C" fn(
2084 PMC: *mut ICapeInterface,
2085 reader: *mut ICapeInterface,
2086 majorVersion: CapeInteger,
2087 minorVersion: CapeInteger,
2088 ) -> CapeResult,
2089>;
2090#[repr(C)]
2091#[derive(Debug, Copy, Clone)]
2092pub struct _COBIAFUNCTIONS {
2093 #[doc = "!< pointer to UUID generation function"]
2094 pub capeGenUUID: CAPEUUIDFUNCVOID,
2095 #[doc = "!< pointer to UUID to string conversion function"]
2096 pub capeStringFromUUID: CAPESTRINGFUNCUUID,
2097 #[doc = "!< pointer to string to UUID conversion function"]
2098 pub capeUUIDFromString: CAPEUUIDFROMSTRING,
2099 #[doc = "!< pointer to COBIA machine-wide data folder function"]
2100 pub getCobiaDataFolder: CAPESTRINGFUNC,
2101 #[doc = "!< pointer to COBIA user data folder function"]
2102 pub getCobiaUserDataFolder: CAPESTRINGFUNC,
2103 #[doc = "!< pointer to COBIA machine-wide binary folder function"]
2104 pub getCobiaFolder: CAPESTRINGFUNC,
2105 #[doc = "!< pointer to COBIA language string function"]
2106 pub getCobiaLanguage: CAPESTRINGFUNC,
2107 #[doc = "!< pointer to COBIA version string function"]
2108 pub getCobiaVersion: CAPESTRINGFUNC,
2109 #[doc = "!< pointer to COBIA error description function"]
2110 pub capeGetErrorDescription: CAPESTRINGFUNCCAPERESULT,
2111 #[doc = "!< pointer to COBIA function to get registry key"]
2112 pub capeGetRegistryKey: CAPEGETREGISTRYKEY,
2113 #[doc = "!< pointer to COBIA function to get PMC enumerator"]
2114 pub capeGetPMCEnumerator: CAPEGETPMCENUMERATOR,
2115 #[doc = "!< pointer to COBIA function to get PMC enumerator"]
2116 pub capeGetLibraryEnumerator: CAPEGETLIBRARYENUMERATOR,
2117 #[doc = "!< pointer to COBIA function to get registry write access"]
2118 pub capeGetRegistryWriter: CAPEGETREGISTRYWRITER,
2119 #[doc = "!< pointer to COBIA function to create PMC instance"]
2120 pub cobiaCreatePMCInstance: COBIACREATEPMCINSTANCE,
2121 #[doc = "!< pointer to COBIA functions to create data class instances"]
2122 pub cobiaDataClassFactories: *mut ICobiaDataClassFactory,
2123 #[doc = "!< pointer to COBIA API function to enable persistence transition"]
2124 pub cobiaDepersistFromTransitionFormat: COBIADEPERSISTFROMTRANSITIONFORMAT,
2125 #[doc = "!< pointer to COBIA API function to enable persistence transition"]
2126 pub cobiaDepersistPMCFromTransitionFormat: COBIADEPERSISTPMCFROMTRANSITIONFORMAT,
2127}
2128#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2129const _: () = {
2130 ["Size of _COBIAFUNCTIONS"][::std::mem::size_of::<_COBIAFUNCTIONS>() - 136usize];
2131 ["Alignment of _COBIAFUNCTIONS"][::std::mem::align_of::<_COBIAFUNCTIONS>() - 8usize];
2132 ["Offset of field: _COBIAFUNCTIONS::capeGenUUID"]
2133 [::std::mem::offset_of!(_COBIAFUNCTIONS, capeGenUUID) - 0usize];
2134 ["Offset of field: _COBIAFUNCTIONS::capeStringFromUUID"]
2135 [::std::mem::offset_of!(_COBIAFUNCTIONS, capeStringFromUUID) - 8usize];
2136 ["Offset of field: _COBIAFUNCTIONS::capeUUIDFromString"]
2137 [::std::mem::offset_of!(_COBIAFUNCTIONS, capeUUIDFromString) - 16usize];
2138 ["Offset of field: _COBIAFUNCTIONS::getCobiaDataFolder"]
2139 [::std::mem::offset_of!(_COBIAFUNCTIONS, getCobiaDataFolder) - 24usize];
2140 ["Offset of field: _COBIAFUNCTIONS::getCobiaUserDataFolder"]
2141 [::std::mem::offset_of!(_COBIAFUNCTIONS, getCobiaUserDataFolder) - 32usize];
2142 ["Offset of field: _COBIAFUNCTIONS::getCobiaFolder"]
2143 [::std::mem::offset_of!(_COBIAFUNCTIONS, getCobiaFolder) - 40usize];
2144 ["Offset of field: _COBIAFUNCTIONS::getCobiaLanguage"]
2145 [::std::mem::offset_of!(_COBIAFUNCTIONS, getCobiaLanguage) - 48usize];
2146 ["Offset of field: _COBIAFUNCTIONS::getCobiaVersion"]
2147 [::std::mem::offset_of!(_COBIAFUNCTIONS, getCobiaVersion) - 56usize];
2148 ["Offset of field: _COBIAFUNCTIONS::capeGetErrorDescription"]
2149 [::std::mem::offset_of!(_COBIAFUNCTIONS, capeGetErrorDescription) - 64usize];
2150 ["Offset of field: _COBIAFUNCTIONS::capeGetRegistryKey"]
2151 [::std::mem::offset_of!(_COBIAFUNCTIONS, capeGetRegistryKey) - 72usize];
2152 ["Offset of field: _COBIAFUNCTIONS::capeGetPMCEnumerator"]
2153 [::std::mem::offset_of!(_COBIAFUNCTIONS, capeGetPMCEnumerator) - 80usize];
2154 ["Offset of field: _COBIAFUNCTIONS::capeGetLibraryEnumerator"]
2155 [::std::mem::offset_of!(_COBIAFUNCTIONS, capeGetLibraryEnumerator) - 88usize];
2156 ["Offset of field: _COBIAFUNCTIONS::capeGetRegistryWriter"]
2157 [::std::mem::offset_of!(_COBIAFUNCTIONS, capeGetRegistryWriter) - 96usize];
2158 ["Offset of field: _COBIAFUNCTIONS::cobiaCreatePMCInstance"]
2159 [::std::mem::offset_of!(_COBIAFUNCTIONS, cobiaCreatePMCInstance) - 104usize];
2160 ["Offset of field: _COBIAFUNCTIONS::cobiaDataClassFactories"]
2161 [::std::mem::offset_of!(_COBIAFUNCTIONS, cobiaDataClassFactories) - 112usize];
2162 ["Offset of field: _COBIAFUNCTIONS::cobiaDepersistFromTransitionFormat"]
2163 [::std::mem::offset_of!(_COBIAFUNCTIONS, cobiaDepersistFromTransitionFormat) - 120usize];
2164 ["Offset of field: _COBIAFUNCTIONS::cobiaDepersistPMCFromTransitionFormat"]
2165 [::std::mem::offset_of!(_COBIAFUNCTIONS, cobiaDepersistPMCFromTransitionFormat) - 128usize];
2166};
2167pub type COBIAFUNCTIONS = _COBIAFUNCTIONS;
2168unsafe extern "C" {
2169 pub fn cobia_getCobiaFunctions() -> *mut COBIAFUNCTIONS;
2170}
2171#[repr(C)]
2172#[derive(Debug, Copy, Clone)]
2173pub struct ICapeIDLAttributeCollection_VTable {
2174 pub AttributeCount:
2175 ::std::option::Option<unsafe extern "C" fn(me: *mut ::std::os::raw::c_void) -> CapeInteger>,
2176 pub AttributeName: ::std::option::Option<
2177 unsafe extern "C" fn(
2178 me: *mut ::std::os::raw::c_void,
2179 index: CapeInteger,
2180 name: *mut ICapeString,
2181 ) -> CapeResult,
2182 >,
2183 pub AttributeValue: ::std::option::Option<
2184 unsafe extern "C" fn(
2185 me: *mut ::std::os::raw::c_void,
2186 index: CapeInteger,
2187 value: *mut ICapeString,
2188 ) -> CapeResult,
2189 >,
2190 pub AttributeValueByName: ::std::option::Option<
2191 unsafe extern "C" fn(
2192 me: *mut ::std::os::raw::c_void,
2193 attribute: *mut ICapeString,
2194 value: *mut ICapeString,
2195 ) -> CapeResult,
2196 >,
2197 pub HasAttribute: ::std::option::Option<
2198 unsafe extern "C" fn(
2199 me: *mut ::std::os::raw::c_void,
2200 attribute: *mut ICapeString,
2201 ) -> CapeBoolean,
2202 >,
2203}
2204#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2205const _: () = {
2206 ["Size of ICapeIDLAttributeCollection_VTable"]
2207 [::std::mem::size_of::<ICapeIDLAttributeCollection_VTable>() - 40usize];
2208 ["Alignment of ICapeIDLAttributeCollection_VTable"]
2209 [::std::mem::align_of::<ICapeIDLAttributeCollection_VTable>() - 8usize];
2210 ["Offset of field: ICapeIDLAttributeCollection_VTable::AttributeCount"]
2211 [::std::mem::offset_of!(ICapeIDLAttributeCollection_VTable, AttributeCount) - 0usize];
2212 ["Offset of field: ICapeIDLAttributeCollection_VTable::AttributeName"]
2213 [::std::mem::offset_of!(ICapeIDLAttributeCollection_VTable, AttributeName) - 8usize];
2214 ["Offset of field: ICapeIDLAttributeCollection_VTable::AttributeValue"]
2215 [::std::mem::offset_of!(ICapeIDLAttributeCollection_VTable, AttributeValue) - 16usize];
2216 ["Offset of field: ICapeIDLAttributeCollection_VTable::AttributeValueByName"][::std::mem::offset_of!(
2217 ICapeIDLAttributeCollection_VTable,
2218 AttributeValueByName
2219 ) - 24usize];
2220 ["Offset of field: ICapeIDLAttributeCollection_VTable::HasAttribute"]
2221 [::std::mem::offset_of!(ICapeIDLAttributeCollection_VTable, HasAttribute) - 32usize];
2222};
2223#[repr(C)]
2224#[derive(Debug, Copy, Clone)]
2225pub struct _ICapeIDLAttributeCollection {
2226 pub me: *mut ::std::os::raw::c_void,
2227 pub vTbl: *mut ICapeIDLAttributeCollection_VTable,
2228}
2229#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2230const _: () = {
2231 ["Size of _ICapeIDLAttributeCollection"]
2232 [::std::mem::size_of::<_ICapeIDLAttributeCollection>() - 16usize];
2233 ["Alignment of _ICapeIDLAttributeCollection"]
2234 [::std::mem::align_of::<_ICapeIDLAttributeCollection>() - 8usize];
2235 ["Offset of field: _ICapeIDLAttributeCollection::me"]
2236 [::std::mem::offset_of!(_ICapeIDLAttributeCollection, me) - 0usize];
2237 ["Offset of field: _ICapeIDLAttributeCollection::vTbl"]
2238 [::std::mem::offset_of!(_ICapeIDLAttributeCollection, vTbl) - 8usize];
2239};
2240pub type ICapeIDLAttributeCollection = _ICapeIDLAttributeCollection;
2241#[doc = "!<Not a valid data type"]
2242pub const eCapeIDLDataType_IDLDataType_CapeInvalidType: eCapeIDLDataType = 0;
2243#[doc = "!<CAPERESULT value"]
2244pub const eCapeIDLDataType_IDLDataType_CapeResult: eCapeIDLDataType = 1;
2245#[doc = "!<CapeString value"]
2246pub const eCapeIDLDataType_IDLDataType_CapeString: eCapeIDLDataType = 2;
2247#[doc = "!<CapeInteger value"]
2248pub const eCapeIDLDataType_IDLDataType_CapeInteger: eCapeIDLDataType = 3;
2249#[doc = "!<CapeBoolean value"]
2250pub const eCapeIDLDataType_IDLDataType_CapeBoolean: eCapeIDLDataType = 4;
2251#[doc = "!<CapeReal value"]
2252pub const eCapeIDLDataType_IDLDataType_CapeReal: eCapeIDLDataType = 5;
2253#[doc = "!<CapeInterface value; requires uuid (nullptr uuid identifies CapeObject type)"]
2254pub const eCapeIDLDataType_IDLDataType_CapeInterface: eCapeIDLDataType = 6;
2255#[doc = "!<CapeArrayString value"]
2256pub const eCapeIDLDataType_IDLDataType_CapeArrayString: eCapeIDLDataType = 7;
2257#[doc = "!<CapeValue value"]
2258pub const eCapeIDLDataType_IDLDataType_CapeValue: eCapeIDLDataType = 8;
2259#[doc = "!<CapeArrayInteger value"]
2260pub const eCapeIDLDataType_IDLDataType_CapeArrayInteger: eCapeIDLDataType = 9;
2261#[doc = "!<CapeArrayBoolean value"]
2262pub const eCapeIDLDataType_IDLDataType_CapeArrayBoolean: eCapeIDLDataType = 10;
2263#[doc = "!<CapeArrayReal value"]
2264pub const eCapeIDLDataType_IDLDataType_CapeArrayReal: eCapeIDLDataType = 11;
2265#[doc = "!<CapeArrayEnumeration value, requires template argument"]
2266pub const eCapeIDLDataType_IDLDataType_CapeArrayEnumeration: eCapeIDLDataType = 12;
2267#[doc = "!<CapeEnumeration value, requires uuid (or is generic enumeration in case of null uuid)"]
2268pub const eCapeIDLDataType_IDLDataType_CapeEnumeration: eCapeIDLDataType = 13;
2269#[doc = "!<CapeArrayValue value"]
2270pub const eCapeIDLDataType_IDLDataType_CapeArrayValue: eCapeIDLDataType = 14;
2271#[doc = "!<CapeArrayByte value"]
2272pub const eCapeIDLDataType_IDLDataType_CapeArrayByte: eCapeIDLDataType = 15;
2273#[doc = "!<UUID value"]
2274pub const eCapeIDLDataType_IDLDataType_CapeUUID: eCapeIDLDataType = 16;
2275#[doc = "!<Parent window ID in ICapeUtilities::Edit"]
2276pub const eCapeIDLDataType_IDLDataType_CapeWindowId: eCapeIDLDataType = 17;
2277#[doc = "!<Argument to a template value, requires template index"]
2278pub const eCapeIDLDataType_IDLDataType_CapeTemplateArgument: eCapeIDLDataType = 18;
2279pub type eCapeIDLDataType = i32;
2280pub use self::eCapeIDLDataType as CapeIDLDataType;
2281#[repr(C)]
2282#[derive(Debug, Copy, Clone)]
2283pub struct ICapeIDLCategoryID_VTable {
2284 pub attribs: ICapeIDLAttributeCollection_VTable,
2285 pub Name: ::std::option::Option<
2286 unsafe extern "C" fn(me: *mut ::std::os::raw::c_void, name: *mut ICapeString),
2287 >,
2288 pub Uuid: ::std::option::Option<
2289 unsafe extern "C" fn(me: *mut ::std::os::raw::c_void) -> *const u8,
2290 >,
2291 pub LibraryUuid: ::std::option::Option<
2292 unsafe extern "C" fn(me: *mut ::std::os::raw::c_void) -> *const u8,
2293 >,
2294 pub LibraryName: ::std::option::Option<
2295 unsafe extern "C" fn(me: *mut ::std::os::raw::c_void, name: *mut ICapeString),
2296 >,
2297}
2298#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2299const _: () = {
2300 ["Size of ICapeIDLCategoryID_VTable"]
2301 [::std::mem::size_of::<ICapeIDLCategoryID_VTable>() - 72usize];
2302 ["Alignment of ICapeIDLCategoryID_VTable"]
2303 [::std::mem::align_of::<ICapeIDLCategoryID_VTable>() - 8usize];
2304 ["Offset of field: ICapeIDLCategoryID_VTable::attribs"]
2305 [::std::mem::offset_of!(ICapeIDLCategoryID_VTable, attribs) - 0usize];
2306 ["Offset of field: ICapeIDLCategoryID_VTable::Name"]
2307 [::std::mem::offset_of!(ICapeIDLCategoryID_VTable, Name) - 40usize];
2308 ["Offset of field: ICapeIDLCategoryID_VTable::Uuid"]
2309 [::std::mem::offset_of!(ICapeIDLCategoryID_VTable, Uuid) - 48usize];
2310 ["Offset of field: ICapeIDLCategoryID_VTable::LibraryUuid"]
2311 [::std::mem::offset_of!(ICapeIDLCategoryID_VTable, LibraryUuid) - 56usize];
2312 ["Offset of field: ICapeIDLCategoryID_VTable::LibraryName"]
2313 [::std::mem::offset_of!(ICapeIDLCategoryID_VTable, LibraryName) - 64usize];
2314};
2315#[repr(C)]
2316#[derive(Debug, Copy, Clone)]
2317pub struct _ICapeIDLCategoryID {
2318 pub me: *mut ::std::os::raw::c_void,
2319 pub vTbl: *mut ICapeIDLCategoryID_VTable,
2320}
2321#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2322const _: () = {
2323 ["Size of _ICapeIDLCategoryID"][::std::mem::size_of::<_ICapeIDLCategoryID>() - 16usize];
2324 ["Alignment of _ICapeIDLCategoryID"][::std::mem::align_of::<_ICapeIDLCategoryID>() - 8usize];
2325 ["Offset of field: _ICapeIDLCategoryID::me"]
2326 [::std::mem::offset_of!(_ICapeIDLCategoryID, me) - 0usize];
2327 ["Offset of field: _ICapeIDLCategoryID::vTbl"]
2328 [::std::mem::offset_of!(_ICapeIDLCategoryID, vTbl) - 8usize];
2329};
2330pub type ICapeIDLCategoryID = _ICapeIDLCategoryID;
2331#[repr(C)]
2332#[derive(Debug, Copy, Clone)]
2333pub struct ICapeIDLCategoryIDCollection_VTable {
2334 pub CategoryIDCount:
2335 ::std::option::Option<unsafe extern "C" fn(me: *mut ::std::os::raw::c_void) -> CapeInteger>,
2336 pub CategoryID: ::std::option::Option<
2337 unsafe extern "C" fn(
2338 me: *mut ::std::os::raw::c_void,
2339 index: CapeInteger,
2340 catID: *mut *mut ICapeIDLCategoryID,
2341 ) -> CapeResult,
2342 >,
2343 pub CategoryIDByName: ::std::option::Option<
2344 unsafe extern "C" fn(
2345 me: *mut ::std::os::raw::c_void,
2346 catName: *mut ICapeString,
2347 catID: *mut *mut ICapeIDLCategoryID,
2348 ) -> CapeResult,
2349 >,
2350 pub CategoryIDByUUID: ::std::option::Option<
2351 unsafe extern "C" fn(
2352 me: *mut ::std::os::raw::c_void,
2353 uuid: *const u8,
2354 catID: *mut *mut ICapeIDLCategoryID,
2355 ) -> CapeResult,
2356 >,
2357}
2358#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2359const _: () = {
2360 ["Size of ICapeIDLCategoryIDCollection_VTable"]
2361 [::std::mem::size_of::<ICapeIDLCategoryIDCollection_VTable>() - 32usize];
2362 ["Alignment of ICapeIDLCategoryIDCollection_VTable"]
2363 [::std::mem::align_of::<ICapeIDLCategoryIDCollection_VTable>() - 8usize];
2364 ["Offset of field: ICapeIDLCategoryIDCollection_VTable::CategoryIDCount"]
2365 [::std::mem::offset_of!(ICapeIDLCategoryIDCollection_VTable, CategoryIDCount) - 0usize];
2366 ["Offset of field: ICapeIDLCategoryIDCollection_VTable::CategoryID"]
2367 [::std::mem::offset_of!(ICapeIDLCategoryIDCollection_VTable, CategoryID) - 8usize];
2368 ["Offset of field: ICapeIDLCategoryIDCollection_VTable::CategoryIDByName"]
2369 [::std::mem::offset_of!(ICapeIDLCategoryIDCollection_VTable, CategoryIDByName) - 16usize];
2370 ["Offset of field: ICapeIDLCategoryIDCollection_VTable::CategoryIDByUUID"]
2371 [::std::mem::offset_of!(ICapeIDLCategoryIDCollection_VTable, CategoryIDByUUID) - 24usize];
2372};
2373#[repr(C)]
2374#[derive(Debug, Copy, Clone)]
2375pub struct _ICapeIDLCategoryIDCollection {
2376 pub me: *mut ::std::os::raw::c_void,
2377 pub vTbl: *mut ICapeIDLCategoryIDCollection_VTable,
2378}
2379#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2380const _: () = {
2381 ["Size of _ICapeIDLCategoryIDCollection"]
2382 [::std::mem::size_of::<_ICapeIDLCategoryIDCollection>() - 16usize];
2383 ["Alignment of _ICapeIDLCategoryIDCollection"]
2384 [::std::mem::align_of::<_ICapeIDLCategoryIDCollection>() - 8usize];
2385 ["Offset of field: _ICapeIDLCategoryIDCollection::me"]
2386 [::std::mem::offset_of!(_ICapeIDLCategoryIDCollection, me) - 0usize];
2387 ["Offset of field: _ICapeIDLCategoryIDCollection::vTbl"]
2388 [::std::mem::offset_of!(_ICapeIDLCategoryIDCollection, vTbl) - 8usize];
2389};
2390pub type ICapeIDLCategoryIDCollection = _ICapeIDLCategoryIDCollection;
2391#[repr(C)]
2392#[derive(Debug, Copy, Clone)]
2393pub struct ICapeIDLEnumeration_VTable {
2394 pub attribs: ICapeIDLAttributeCollection_VTable,
2395 pub Name: ::std::option::Option<
2396 unsafe extern "C" fn(me: *mut ::std::os::raw::c_void, name: *mut ICapeString),
2397 >,
2398 pub Uuid: ::std::option::Option<
2399 unsafe extern "C" fn(me: *mut ::std::os::raw::c_void) -> *const u8,
2400 >,
2401 pub LibraryUuid: ::std::option::Option<
2402 unsafe extern "C" fn(me: *mut ::std::os::raw::c_void) -> *const u8,
2403 >,
2404 pub LibraryName: ::std::option::Option<
2405 unsafe extern "C" fn(me: *mut ::std::os::raw::c_void, name: *mut ICapeString),
2406 >,
2407 pub Count:
2408 ::std::option::Option<unsafe extern "C" fn(me: *mut ::std::os::raw::c_void) -> CapeInteger>,
2409 pub ItemName: ::std::option::Option<
2410 unsafe extern "C" fn(
2411 me: *mut ::std::os::raw::c_void,
2412 index: CapeInteger,
2413 name: *mut ICapeString,
2414 ) -> CapeResult,
2415 >,
2416 pub ItemValue: ::std::option::Option<
2417 unsafe extern "C" fn(
2418 me: *mut ::std::os::raw::c_void,
2419 index: CapeInteger,
2420 value: *mut CapeInteger,
2421 ) -> CapeResult,
2422 >,
2423 pub ItemValueByName: ::std::option::Option<
2424 unsafe extern "C" fn(
2425 me: *mut ::std::os::raw::c_void,
2426 valueName: *mut ICapeString,
2427 value: *mut CapeInteger,
2428 ) -> CapeResult,
2429 >,
2430 pub HasValue: ::std::option::Option<
2431 unsafe extern "C" fn(
2432 me: *mut ::std::os::raw::c_void,
2433 valueName: *mut ICapeString,
2434 ) -> CapeBoolean,
2435 >,
2436}
2437#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2438const _: () = {
2439 ["Size of ICapeIDLEnumeration_VTable"]
2440 [::std::mem::size_of::<ICapeIDLEnumeration_VTable>() - 112usize];
2441 ["Alignment of ICapeIDLEnumeration_VTable"]
2442 [::std::mem::align_of::<ICapeIDLEnumeration_VTable>() - 8usize];
2443 ["Offset of field: ICapeIDLEnumeration_VTable::attribs"]
2444 [::std::mem::offset_of!(ICapeIDLEnumeration_VTable, attribs) - 0usize];
2445 ["Offset of field: ICapeIDLEnumeration_VTable::Name"]
2446 [::std::mem::offset_of!(ICapeIDLEnumeration_VTable, Name) - 40usize];
2447 ["Offset of field: ICapeIDLEnumeration_VTable::Uuid"]
2448 [::std::mem::offset_of!(ICapeIDLEnumeration_VTable, Uuid) - 48usize];
2449 ["Offset of field: ICapeIDLEnumeration_VTable::LibraryUuid"]
2450 [::std::mem::offset_of!(ICapeIDLEnumeration_VTable, LibraryUuid) - 56usize];
2451 ["Offset of field: ICapeIDLEnumeration_VTable::LibraryName"]
2452 [::std::mem::offset_of!(ICapeIDLEnumeration_VTable, LibraryName) - 64usize];
2453 ["Offset of field: ICapeIDLEnumeration_VTable::Count"]
2454 [::std::mem::offset_of!(ICapeIDLEnumeration_VTable, Count) - 72usize];
2455 ["Offset of field: ICapeIDLEnumeration_VTable::ItemName"]
2456 [::std::mem::offset_of!(ICapeIDLEnumeration_VTable, ItemName) - 80usize];
2457 ["Offset of field: ICapeIDLEnumeration_VTable::ItemValue"]
2458 [::std::mem::offset_of!(ICapeIDLEnumeration_VTable, ItemValue) - 88usize];
2459 ["Offset of field: ICapeIDLEnumeration_VTable::ItemValueByName"]
2460 [::std::mem::offset_of!(ICapeIDLEnumeration_VTable, ItemValueByName) - 96usize];
2461 ["Offset of field: ICapeIDLEnumeration_VTable::HasValue"]
2462 [::std::mem::offset_of!(ICapeIDLEnumeration_VTable, HasValue) - 104usize];
2463};
2464#[repr(C)]
2465#[derive(Debug, Copy, Clone)]
2466pub struct _ICapeIDLEnumeration {
2467 pub me: *mut ::std::os::raw::c_void,
2468 pub vTbl: *mut ICapeIDLEnumeration_VTable,
2469}
2470#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2471const _: () = {
2472 ["Size of _ICapeIDLEnumeration"][::std::mem::size_of::<_ICapeIDLEnumeration>() - 16usize];
2473 ["Alignment of _ICapeIDLEnumeration"][::std::mem::align_of::<_ICapeIDLEnumeration>() - 8usize];
2474 ["Offset of field: _ICapeIDLEnumeration::me"]
2475 [::std::mem::offset_of!(_ICapeIDLEnumeration, me) - 0usize];
2476 ["Offset of field: _ICapeIDLEnumeration::vTbl"]
2477 [::std::mem::offset_of!(_ICapeIDLEnumeration, vTbl) - 8usize];
2478};
2479pub type ICapeIDLEnumeration = _ICapeIDLEnumeration;
2480#[repr(C)]
2481#[derive(Debug, Copy, Clone)]
2482pub struct ICapeIDLEnumCollection_VTable {
2483 pub EnumCount:
2484 ::std::option::Option<unsafe extern "C" fn(me: *mut ::std::os::raw::c_void) -> CapeInteger>,
2485 pub Enumeration: ::std::option::Option<
2486 unsafe extern "C" fn(
2487 me: *mut ::std::os::raw::c_void,
2488 index: CapeInteger,
2489 enumeration: *mut *mut ICapeIDLEnumeration,
2490 ) -> CapeResult,
2491 >,
2492 pub EnumerationByName: ::std::option::Option<
2493 unsafe extern "C" fn(
2494 me: *mut ::std::os::raw::c_void,
2495 enumName: *mut ICapeString,
2496 enumeration: *mut *mut ICapeIDLEnumeration,
2497 ) -> CapeResult,
2498 >,
2499 pub EnumerationByUUID: ::std::option::Option<
2500 unsafe extern "C" fn(
2501 me: *mut ::std::os::raw::c_void,
2502 uuid: *const u8,
2503 enumeration: *mut *mut ICapeIDLEnumeration,
2504 ) -> CapeResult,
2505 >,
2506}
2507#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2508const _: () = {
2509 ["Size of ICapeIDLEnumCollection_VTable"]
2510 [::std::mem::size_of::<ICapeIDLEnumCollection_VTable>() - 32usize];
2511 ["Alignment of ICapeIDLEnumCollection_VTable"]
2512 [::std::mem::align_of::<ICapeIDLEnumCollection_VTable>() - 8usize];
2513 ["Offset of field: ICapeIDLEnumCollection_VTable::EnumCount"]
2514 [::std::mem::offset_of!(ICapeIDLEnumCollection_VTable, EnumCount) - 0usize];
2515 ["Offset of field: ICapeIDLEnumCollection_VTable::Enumeration"]
2516 [::std::mem::offset_of!(ICapeIDLEnumCollection_VTable, Enumeration) - 8usize];
2517 ["Offset of field: ICapeIDLEnumCollection_VTable::EnumerationByName"]
2518 [::std::mem::offset_of!(ICapeIDLEnumCollection_VTable, EnumerationByName) - 16usize];
2519 ["Offset of field: ICapeIDLEnumCollection_VTable::EnumerationByUUID"]
2520 [::std::mem::offset_of!(ICapeIDLEnumCollection_VTable, EnumerationByUUID) - 24usize];
2521};
2522#[repr(C)]
2523#[derive(Debug, Copy, Clone)]
2524pub struct _ICapeIDLEnumCollection {
2525 pub me: *mut ::std::os::raw::c_void,
2526 pub vTbl: *mut ICapeIDLEnumCollection_VTable,
2527}
2528#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2529const _: () = {
2530 ["Size of _ICapeIDLEnumCollection"][::std::mem::size_of::<_ICapeIDLEnumCollection>() - 16usize];
2531 ["Alignment of _ICapeIDLEnumCollection"]
2532 [::std::mem::align_of::<_ICapeIDLEnumCollection>() - 8usize];
2533 ["Offset of field: _ICapeIDLEnumCollection::me"]
2534 [::std::mem::offset_of!(_ICapeIDLEnumCollection, me) - 0usize];
2535 ["Offset of field: _ICapeIDLEnumCollection::vTbl"]
2536 [::std::mem::offset_of!(_ICapeIDLEnumCollection, vTbl) - 8usize];
2537};
2538pub type ICapeIDLEnumCollection = _ICapeIDLEnumCollection;
2539#[repr(C)]
2540#[derive(Debug, Copy, Clone)]
2541pub struct ICapeIDLDataType_VTable {
2542 pub Uuid: ::std::option::Option<
2543 unsafe extern "C" fn(me: *mut ::std::os::raw::c_void) -> *const u8,
2544 >,
2545 pub Name: ::std::option::Option<
2546 unsafe extern "C" fn(me: *mut ::std::os::raw::c_void, name: *mut ICapeString),
2547 >,
2548 pub Type: ::std::option::Option<
2549 unsafe extern "C" fn(me: *mut ::std::os::raw::c_void) -> CapeIDLDataType,
2550 >,
2551 pub TemplateIndex:
2552 ::std::option::Option<unsafe extern "C" fn(me: *mut ::std::os::raw::c_void) -> CapeInteger>,
2553 pub TemplateTypeCount:
2554 ::std::option::Option<unsafe extern "C" fn(me: *mut ::std::os::raw::c_void) -> CapeInteger>,
2555 pub TemplateType: ::std::option::Option<
2556 unsafe extern "C" fn(
2557 me: *mut ::std::os::raw::c_void,
2558 index: CapeInteger,
2559 datatype: *mut *mut _ICapeIDLDataType,
2560 ) -> CapeResult,
2561 >,
2562}
2563#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2564const _: () = {
2565 ["Size of ICapeIDLDataType_VTable"][::std::mem::size_of::<ICapeIDLDataType_VTable>() - 48usize];
2566 ["Alignment of ICapeIDLDataType_VTable"]
2567 [::std::mem::align_of::<ICapeIDLDataType_VTable>() - 8usize];
2568 ["Offset of field: ICapeIDLDataType_VTable::Uuid"]
2569 [::std::mem::offset_of!(ICapeIDLDataType_VTable, Uuid) - 0usize];
2570 ["Offset of field: ICapeIDLDataType_VTable::Name"]
2571 [::std::mem::offset_of!(ICapeIDLDataType_VTable, Name) - 8usize];
2572 ["Offset of field: ICapeIDLDataType_VTable::Type"]
2573 [::std::mem::offset_of!(ICapeIDLDataType_VTable, Type) - 16usize];
2574 ["Offset of field: ICapeIDLDataType_VTable::TemplateIndex"]
2575 [::std::mem::offset_of!(ICapeIDLDataType_VTable, TemplateIndex) - 24usize];
2576 ["Offset of field: ICapeIDLDataType_VTable::TemplateTypeCount"]
2577 [::std::mem::offset_of!(ICapeIDLDataType_VTable, TemplateTypeCount) - 32usize];
2578 ["Offset of field: ICapeIDLDataType_VTable::TemplateType"]
2579 [::std::mem::offset_of!(ICapeIDLDataType_VTable, TemplateType) - 40usize];
2580};
2581#[repr(C)]
2582#[derive(Debug, Copy, Clone)]
2583pub struct _ICapeIDLDataType {
2584 pub me: *mut ::std::os::raw::c_void,
2585 pub vTbl: *mut ICapeIDLDataType_VTable,
2586}
2587#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2588const _: () = {
2589 ["Size of _ICapeIDLDataType"][::std::mem::size_of::<_ICapeIDLDataType>() - 16usize];
2590 ["Alignment of _ICapeIDLDataType"][::std::mem::align_of::<_ICapeIDLDataType>() - 8usize];
2591 ["Offset of field: _ICapeIDLDataType::me"]
2592 [::std::mem::offset_of!(_ICapeIDLDataType, me) - 0usize];
2593 ["Offset of field: _ICapeIDLDataType::vTbl"]
2594 [::std::mem::offset_of!(_ICapeIDLDataType, vTbl) - 8usize];
2595};
2596pub type ICapeIDLDataType = _ICapeIDLDataType;
2597#[repr(C)]
2598#[derive(Debug, Copy, Clone)]
2599pub struct ICapeIDLMethodArgument_VTable {
2600 pub attribs: ICapeIDLAttributeCollection_VTable,
2601 pub DataType: ::std::option::Option<
2602 unsafe extern "C" fn(me: *mut ::std::os::raw::c_void) -> *mut ICapeIDLDataType,
2603 >,
2604 pub Name: ::std::option::Option<
2605 unsafe extern "C" fn(me: *mut ::std::os::raw::c_void, name: *mut ICapeString),
2606 >,
2607}
2608#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2609const _: () = {
2610 ["Size of ICapeIDLMethodArgument_VTable"]
2611 [::std::mem::size_of::<ICapeIDLMethodArgument_VTable>() - 56usize];
2612 ["Alignment of ICapeIDLMethodArgument_VTable"]
2613 [::std::mem::align_of::<ICapeIDLMethodArgument_VTable>() - 8usize];
2614 ["Offset of field: ICapeIDLMethodArgument_VTable::attribs"]
2615 [::std::mem::offset_of!(ICapeIDLMethodArgument_VTable, attribs) - 0usize];
2616 ["Offset of field: ICapeIDLMethodArgument_VTable::DataType"]
2617 [::std::mem::offset_of!(ICapeIDLMethodArgument_VTable, DataType) - 40usize];
2618 ["Offset of field: ICapeIDLMethodArgument_VTable::Name"]
2619 [::std::mem::offset_of!(ICapeIDLMethodArgument_VTable, Name) - 48usize];
2620};
2621#[repr(C)]
2622#[derive(Debug, Copy, Clone)]
2623pub struct _ICapeIDLMethodArgument {
2624 pub me: *mut ::std::os::raw::c_void,
2625 pub vTbl: *mut ICapeIDLMethodArgument_VTable,
2626}
2627#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2628const _: () = {
2629 ["Size of _ICapeIDLMethodArgument"][::std::mem::size_of::<_ICapeIDLMethodArgument>() - 16usize];
2630 ["Alignment of _ICapeIDLMethodArgument"]
2631 [::std::mem::align_of::<_ICapeIDLMethodArgument>() - 8usize];
2632 ["Offset of field: _ICapeIDLMethodArgument::me"]
2633 [::std::mem::offset_of!(_ICapeIDLMethodArgument, me) - 0usize];
2634 ["Offset of field: _ICapeIDLMethodArgument::vTbl"]
2635 [::std::mem::offset_of!(_ICapeIDLMethodArgument, vTbl) - 8usize];
2636};
2637pub type ICapeIDLMethodArgument = _ICapeIDLMethodArgument;
2638#[repr(C)]
2639#[derive(Debug, Copy, Clone)]
2640pub struct ICapeIDLMethod_VTable {
2641 pub attribs: ICapeIDLAttributeCollection_VTable,
2642 pub Name: ::std::option::Option<
2643 unsafe extern "C" fn(me: *mut ::std::os::raw::c_void, name: *mut ICapeString),
2644 >,
2645 pub ReturnType: ::std::option::Option<
2646 unsafe extern "C" fn(
2647 me: *mut ::std::os::raw::c_void,
2648 returntype: *mut *mut ICapeIDLDataType,
2649 ),
2650 >,
2651 pub ArgumentCount:
2652 ::std::option::Option<unsafe extern "C" fn(me: *mut ::std::os::raw::c_void) -> CapeInteger>,
2653 pub Argument: ::std::option::Option<
2654 unsafe extern "C" fn(
2655 me: *mut ::std::os::raw::c_void,
2656 index: CapeInteger,
2657 arg: *mut *mut ICapeIDLMethodArgument,
2658 ) -> CapeResult,
2659 >,
2660}
2661#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2662const _: () = {
2663 ["Size of ICapeIDLMethod_VTable"][::std::mem::size_of::<ICapeIDLMethod_VTable>() - 72usize];
2664 ["Alignment of ICapeIDLMethod_VTable"]
2665 [::std::mem::align_of::<ICapeIDLMethod_VTable>() - 8usize];
2666 ["Offset of field: ICapeIDLMethod_VTable::attribs"]
2667 [::std::mem::offset_of!(ICapeIDLMethod_VTable, attribs) - 0usize];
2668 ["Offset of field: ICapeIDLMethod_VTable::Name"]
2669 [::std::mem::offset_of!(ICapeIDLMethod_VTable, Name) - 40usize];
2670 ["Offset of field: ICapeIDLMethod_VTable::ReturnType"]
2671 [::std::mem::offset_of!(ICapeIDLMethod_VTable, ReturnType) - 48usize];
2672 ["Offset of field: ICapeIDLMethod_VTable::ArgumentCount"]
2673 [::std::mem::offset_of!(ICapeIDLMethod_VTable, ArgumentCount) - 56usize];
2674 ["Offset of field: ICapeIDLMethod_VTable::Argument"]
2675 [::std::mem::offset_of!(ICapeIDLMethod_VTable, Argument) - 64usize];
2676};
2677#[repr(C)]
2678#[derive(Debug, Copy, Clone)]
2679pub struct _ICapeIDLMethod {
2680 pub me: *mut ::std::os::raw::c_void,
2681 pub vTbl: *mut ICapeIDLMethod_VTable,
2682}
2683#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2684const _: () = {
2685 ["Size of _ICapeIDLMethod"][::std::mem::size_of::<_ICapeIDLMethod>() - 16usize];
2686 ["Alignment of _ICapeIDLMethod"][::std::mem::align_of::<_ICapeIDLMethod>() - 8usize];
2687 ["Offset of field: _ICapeIDLMethod::me"][::std::mem::offset_of!(_ICapeIDLMethod, me) - 0usize];
2688 ["Offset of field: _ICapeIDLMethod::vTbl"]
2689 [::std::mem::offset_of!(_ICapeIDLMethod, vTbl) - 8usize];
2690};
2691pub type ICapeIDLMethod = _ICapeIDLMethod;
2692#[repr(C)]
2693#[derive(Debug, Copy, Clone)]
2694pub struct ICapeIDLInterface_VTable {
2695 pub attribs: ICapeIDLAttributeCollection_VTable,
2696 pub Name: ::std::option::Option<
2697 unsafe extern "C" fn(me: *mut ::std::os::raw::c_void, name: *mut ICapeString),
2698 >,
2699 pub Uuid: ::std::option::Option<
2700 unsafe extern "C" fn(me: *mut ::std::os::raw::c_void) -> *const u8,
2701 >,
2702 pub LibraryUuid: ::std::option::Option<
2703 unsafe extern "C" fn(me: *mut ::std::os::raw::c_void) -> *const u8,
2704 >,
2705 pub LibraryName: ::std::option::Option<
2706 unsafe extern "C" fn(me: *mut ::std::os::raw::c_void, name: *mut ICapeString),
2707 >,
2708 pub MethodCount:
2709 ::std::option::Option<unsafe extern "C" fn(me: *mut ::std::os::raw::c_void) -> CapeInteger>,
2710 pub Method: ::std::option::Option<
2711 unsafe extern "C" fn(
2712 me: *mut ::std::os::raw::c_void,
2713 index: CapeInteger,
2714 method: *mut *mut ICapeIDLMethod,
2715 ) -> CapeResult,
2716 >,
2717 pub TemplateArgCount:
2718 ::std::option::Option<unsafe extern "C" fn(me: *mut ::std::os::raw::c_void) -> CapeInteger>,
2719 pub TemplateArg: ::std::option::Option<
2720 unsafe extern "C" fn(
2721 me: *mut ::std::os::raw::c_void,
2722 index: CapeInteger,
2723 name: *mut ICapeString,
2724 ) -> CapeResult,
2725 >,
2726}
2727#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2728const _: () = {
2729 ["Size of ICapeIDLInterface_VTable"]
2730 [::std::mem::size_of::<ICapeIDLInterface_VTable>() - 104usize];
2731 ["Alignment of ICapeIDLInterface_VTable"]
2732 [::std::mem::align_of::<ICapeIDLInterface_VTable>() - 8usize];
2733 ["Offset of field: ICapeIDLInterface_VTable::attribs"]
2734 [::std::mem::offset_of!(ICapeIDLInterface_VTable, attribs) - 0usize];
2735 ["Offset of field: ICapeIDLInterface_VTable::Name"]
2736 [::std::mem::offset_of!(ICapeIDLInterface_VTable, Name) - 40usize];
2737 ["Offset of field: ICapeIDLInterface_VTable::Uuid"]
2738 [::std::mem::offset_of!(ICapeIDLInterface_VTable, Uuid) - 48usize];
2739 ["Offset of field: ICapeIDLInterface_VTable::LibraryUuid"]
2740 [::std::mem::offset_of!(ICapeIDLInterface_VTable, LibraryUuid) - 56usize];
2741 ["Offset of field: ICapeIDLInterface_VTable::LibraryName"]
2742 [::std::mem::offset_of!(ICapeIDLInterface_VTable, LibraryName) - 64usize];
2743 ["Offset of field: ICapeIDLInterface_VTable::MethodCount"]
2744 [::std::mem::offset_of!(ICapeIDLInterface_VTable, MethodCount) - 72usize];
2745 ["Offset of field: ICapeIDLInterface_VTable::Method"]
2746 [::std::mem::offset_of!(ICapeIDLInterface_VTable, Method) - 80usize];
2747 ["Offset of field: ICapeIDLInterface_VTable::TemplateArgCount"]
2748 [::std::mem::offset_of!(ICapeIDLInterface_VTable, TemplateArgCount) - 88usize];
2749 ["Offset of field: ICapeIDLInterface_VTable::TemplateArg"]
2750 [::std::mem::offset_of!(ICapeIDLInterface_VTable, TemplateArg) - 96usize];
2751};
2752#[repr(C)]
2753#[derive(Debug, Copy, Clone)]
2754pub struct _ICapeIDLInterface {
2755 pub me: *mut ::std::os::raw::c_void,
2756 pub vTbl: *mut ICapeIDLInterface_VTable,
2757}
2758#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2759const _: () = {
2760 ["Size of _ICapeIDLInterface"][::std::mem::size_of::<_ICapeIDLInterface>() - 16usize];
2761 ["Alignment of _ICapeIDLInterface"][::std::mem::align_of::<_ICapeIDLInterface>() - 8usize];
2762 ["Offset of field: _ICapeIDLInterface::me"]
2763 [::std::mem::offset_of!(_ICapeIDLInterface, me) - 0usize];
2764 ["Offset of field: _ICapeIDLInterface::vTbl"]
2765 [::std::mem::offset_of!(_ICapeIDLInterface, vTbl) - 8usize];
2766};
2767pub type ICapeIDLInterface = _ICapeIDLInterface;
2768#[repr(C)]
2769#[derive(Debug, Copy, Clone)]
2770pub struct ICapeIDLInterfaceCollection_VTable {
2771 pub InterfaceCount:
2772 ::std::option::Option<unsafe extern "C" fn(me: *mut ::std::os::raw::c_void) -> CapeInteger>,
2773 pub Interface: ::std::option::Option<
2774 unsafe extern "C" fn(
2775 me: *mut ::std::os::raw::c_void,
2776 index: CapeInteger,
2777 iface: *mut *mut ICapeIDLInterface,
2778 ) -> CapeResult,
2779 >,
2780 pub InterfaceByName: ::std::option::Option<
2781 unsafe extern "C" fn(
2782 me: *mut ::std::os::raw::c_void,
2783 interfaceName: *mut ICapeString,
2784 iface: *mut *mut ICapeIDLInterface,
2785 ) -> CapeResult,
2786 >,
2787 pub InterfaceByUUID: ::std::option::Option<
2788 unsafe extern "C" fn(
2789 me: *mut ::std::os::raw::c_void,
2790 uuid: *const u8,
2791 iface: *mut *mut ICapeIDLInterface,
2792 ) -> CapeResult,
2793 >,
2794 pub SortNoDependence:
2795 ::std::option::Option<unsafe extern "C" fn(me: *mut ::std::os::raw::c_void) -> CapeResult>,
2796}
2797#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2798const _: () = {
2799 ["Size of ICapeIDLInterfaceCollection_VTable"]
2800 [::std::mem::size_of::<ICapeIDLInterfaceCollection_VTable>() - 40usize];
2801 ["Alignment of ICapeIDLInterfaceCollection_VTable"]
2802 [::std::mem::align_of::<ICapeIDLInterfaceCollection_VTable>() - 8usize];
2803 ["Offset of field: ICapeIDLInterfaceCollection_VTable::InterfaceCount"]
2804 [::std::mem::offset_of!(ICapeIDLInterfaceCollection_VTable, InterfaceCount) - 0usize];
2805 ["Offset of field: ICapeIDLInterfaceCollection_VTable::Interface"]
2806 [::std::mem::offset_of!(ICapeIDLInterfaceCollection_VTable, Interface) - 8usize];
2807 ["Offset of field: ICapeIDLInterfaceCollection_VTable::InterfaceByName"]
2808 [::std::mem::offset_of!(ICapeIDLInterfaceCollection_VTable, InterfaceByName) - 16usize];
2809 ["Offset of field: ICapeIDLInterfaceCollection_VTable::InterfaceByUUID"]
2810 [::std::mem::offset_of!(ICapeIDLInterfaceCollection_VTable, InterfaceByUUID) - 24usize];
2811 ["Offset of field: ICapeIDLInterfaceCollection_VTable::SortNoDependence"]
2812 [::std::mem::offset_of!(ICapeIDLInterfaceCollection_VTable, SortNoDependence) - 32usize];
2813};
2814#[repr(C)]
2815#[derive(Debug, Copy, Clone)]
2816pub struct _ICapeIDLInterfaceCollection {
2817 pub me: *mut ::std::os::raw::c_void,
2818 pub vTbl: *mut ICapeIDLInterfaceCollection_VTable,
2819}
2820#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2821const _: () = {
2822 ["Size of _ICapeIDLInterfaceCollection"]
2823 [::std::mem::size_of::<_ICapeIDLInterfaceCollection>() - 16usize];
2824 ["Alignment of _ICapeIDLInterfaceCollection"]
2825 [::std::mem::align_of::<_ICapeIDLInterfaceCollection>() - 8usize];
2826 ["Offset of field: _ICapeIDLInterfaceCollection::me"]
2827 [::std::mem::offset_of!(_ICapeIDLInterfaceCollection, me) - 0usize];
2828 ["Offset of field: _ICapeIDLInterfaceCollection::vTbl"]
2829 [::std::mem::offset_of!(_ICapeIDLInterfaceCollection, vTbl) - 8usize];
2830};
2831pub type ICapeIDLInterfaceCollection = _ICapeIDLInterfaceCollection;
2832#[repr(C)]
2833#[derive(Debug, Copy, Clone)]
2834pub struct ICapeIDLTypeContainer_VTable {
2835 pub catIDs: ICapeIDLCategoryIDCollection_VTable,
2836 pub enums: ICapeIDLEnumCollection_VTable,
2837 pub interfaces: ICapeIDLInterfaceCollection_VTable,
2838}
2839#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2840const _: () = {
2841 ["Size of ICapeIDLTypeContainer_VTable"]
2842 [::std::mem::size_of::<ICapeIDLTypeContainer_VTable>() - 104usize];
2843 ["Alignment of ICapeIDLTypeContainer_VTable"]
2844 [::std::mem::align_of::<ICapeIDLTypeContainer_VTable>() - 8usize];
2845 ["Offset of field: ICapeIDLTypeContainer_VTable::catIDs"]
2846 [::std::mem::offset_of!(ICapeIDLTypeContainer_VTable, catIDs) - 0usize];
2847 ["Offset of field: ICapeIDLTypeContainer_VTable::enums"]
2848 [::std::mem::offset_of!(ICapeIDLTypeContainer_VTable, enums) - 32usize];
2849 ["Offset of field: ICapeIDLTypeContainer_VTable::interfaces"]
2850 [::std::mem::offset_of!(ICapeIDLTypeContainer_VTable, interfaces) - 64usize];
2851};
2852#[repr(C)]
2853#[derive(Debug, Copy, Clone)]
2854pub struct _ICapeIDLTypeContainer {
2855 pub me: *mut ::std::os::raw::c_void,
2856 pub vTbl: *mut ICapeIDLTypeContainer_VTable,
2857}
2858#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2859const _: () = {
2860 ["Size of _ICapeIDLTypeContainer"][::std::mem::size_of::<_ICapeIDLTypeContainer>() - 16usize];
2861 ["Alignment of _ICapeIDLTypeContainer"]
2862 [::std::mem::align_of::<_ICapeIDLTypeContainer>() - 8usize];
2863 ["Offset of field: _ICapeIDLTypeContainer::me"]
2864 [::std::mem::offset_of!(_ICapeIDLTypeContainer, me) - 0usize];
2865 ["Offset of field: _ICapeIDLTypeContainer::vTbl"]
2866 [::std::mem::offset_of!(_ICapeIDLTypeContainer, vTbl) - 8usize];
2867};
2868pub type ICapeIDLTypeContainer = _ICapeIDLTypeContainer;
2869#[repr(C)]
2870#[derive(Debug, Copy, Clone)]
2871pub struct ICapeIDLLibrary_VTable {
2872 pub base: ICobiaBase_VTable,
2873 pub attribs: ICapeIDLAttributeCollection_VTable,
2874 pub types: ICapeIDLTypeContainer_VTable,
2875 pub Name: ::std::option::Option<
2876 unsafe extern "C" fn(me: *mut ::std::os::raw::c_void, name: *mut ICapeString),
2877 >,
2878 pub Uuid: ::std::option::Option<
2879 unsafe extern "C" fn(me: *mut ::std::os::raw::c_void) -> *const u8,
2880 >,
2881 pub Path: ::std::option::Option<
2882 unsafe extern "C" fn(me: *mut ::std::os::raw::c_void, path: *mut ICapeString),
2883 >,
2884}
2885#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2886const _: () = {
2887 ["Size of ICapeIDLLibrary_VTable"][::std::mem::size_of::<ICapeIDLLibrary_VTable>() - 184usize];
2888 ["Alignment of ICapeIDLLibrary_VTable"]
2889 [::std::mem::align_of::<ICapeIDLLibrary_VTable>() - 8usize];
2890 ["Offset of field: ICapeIDLLibrary_VTable::base"]
2891 [::std::mem::offset_of!(ICapeIDLLibrary_VTable, base) - 0usize];
2892 ["Offset of field: ICapeIDLLibrary_VTable::attribs"]
2893 [::std::mem::offset_of!(ICapeIDLLibrary_VTable, attribs) - 16usize];
2894 ["Offset of field: ICapeIDLLibrary_VTable::types"]
2895 [::std::mem::offset_of!(ICapeIDLLibrary_VTable, types) - 56usize];
2896 ["Offset of field: ICapeIDLLibrary_VTable::Name"]
2897 [::std::mem::offset_of!(ICapeIDLLibrary_VTable, Name) - 160usize];
2898 ["Offset of field: ICapeIDLLibrary_VTable::Uuid"]
2899 [::std::mem::offset_of!(ICapeIDLLibrary_VTable, Uuid) - 168usize];
2900 ["Offset of field: ICapeIDLLibrary_VTable::Path"]
2901 [::std::mem::offset_of!(ICapeIDLLibrary_VTable, Path) - 176usize];
2902};
2903#[repr(C)]
2904#[derive(Debug, Copy, Clone)]
2905pub struct _ICapeIDLLibrary {
2906 pub me: *mut ::std::os::raw::c_void,
2907 pub vTbl: *mut ICapeIDLLibrary_VTable,
2908}
2909#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2910const _: () = {
2911 ["Size of _ICapeIDLLibrary"][::std::mem::size_of::<_ICapeIDLLibrary>() - 16usize];
2912 ["Alignment of _ICapeIDLLibrary"][::std::mem::align_of::<_ICapeIDLLibrary>() - 8usize];
2913 ["Offset of field: _ICapeIDLLibrary::me"]
2914 [::std::mem::offset_of!(_ICapeIDLLibrary, me) - 0usize];
2915 ["Offset of field: _ICapeIDLLibrary::vTbl"]
2916 [::std::mem::offset_of!(_ICapeIDLLibrary, vTbl) - 8usize];
2917};
2918pub type ICapeIDLLibrary = _ICapeIDLLibrary;
2919#[repr(C)]
2920#[derive(Debug, Copy, Clone)]
2921pub struct ICapeIDLParseResult_VTable {
2922 pub base: ICobiaBase_VTable,
2923 pub types: ICapeIDLTypeContainer_VTable,
2924 pub GetLibraryCount: ::std::option::Option<
2925 unsafe extern "C" fn(me: *mut ::std::os::raw::c_void) -> i32,
2926 >,
2927 pub GetLibrary: ::std::option::Option<
2928 unsafe extern "C" fn(
2929 me: *mut ::std::os::raw::c_void,
2930 index: CapeInteger,
2931 lib: *mut *mut ICapeIDLLibrary,
2932 ) -> CapeResult,
2933 >,
2934 pub GetError: ::std::option::Option<
2935 unsafe extern "C" fn(me: *mut ::std::os::raw::c_void, error: *mut ICapeString),
2936 >,
2937}
2938#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2939const _: () = {
2940 ["Size of ICapeIDLParseResult_VTable"]
2941 [::std::mem::size_of::<ICapeIDLParseResult_VTable>() - 144usize];
2942 ["Alignment of ICapeIDLParseResult_VTable"]
2943 [::std::mem::align_of::<ICapeIDLParseResult_VTable>() - 8usize];
2944 ["Offset of field: ICapeIDLParseResult_VTable::base"]
2945 [::std::mem::offset_of!(ICapeIDLParseResult_VTable, base) - 0usize];
2946 ["Offset of field: ICapeIDLParseResult_VTable::types"]
2947 [::std::mem::offset_of!(ICapeIDLParseResult_VTable, types) - 16usize];
2948 ["Offset of field: ICapeIDLParseResult_VTable::GetLibraryCount"]
2949 [::std::mem::offset_of!(ICapeIDLParseResult_VTable, GetLibraryCount) - 120usize];
2950 ["Offset of field: ICapeIDLParseResult_VTable::GetLibrary"]
2951 [::std::mem::offset_of!(ICapeIDLParseResult_VTable, GetLibrary) - 128usize];
2952 ["Offset of field: ICapeIDLParseResult_VTable::GetError"]
2953 [::std::mem::offset_of!(ICapeIDLParseResult_VTable, GetError) - 136usize];
2954};
2955#[repr(C)]
2956#[derive(Debug, Copy, Clone)]
2957pub struct _ICapeIDLParseResult {
2958 #[doc = "!<object pointer"]
2959 pub me: *mut ::std::os::raw::c_void,
2960 #[doc = "!<function pointer table"]
2961 pub vTbl: *mut ICapeIDLParseResult_VTable,
2962}
2963#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2964const _: () = {
2965 ["Size of _ICapeIDLParseResult"][::std::mem::size_of::<_ICapeIDLParseResult>() - 16usize];
2966 ["Alignment of _ICapeIDLParseResult"][::std::mem::align_of::<_ICapeIDLParseResult>() - 8usize];
2967 ["Offset of field: _ICapeIDLParseResult::me"]
2968 [::std::mem::offset_of!(_ICapeIDLParseResult, me) - 0usize];
2969 ["Offset of field: _ICapeIDLParseResult::vTbl"]
2970 [::std::mem::offset_of!(_ICapeIDLParseResult, vTbl) - 8usize];
2971};
2972pub type ICapeIDLParseResult = _ICapeIDLParseResult;
2973unsafe extern "C" {
2974 pub fn CapeIDLParse(idlFiles: *mut ICapeArrayString) -> *mut ICapeIDLParseResult;
2975}
2976unsafe extern "C" {
2977 pub fn capeInitialize(error: *mut ICapeString) -> bool;
2978}
2979unsafe extern "C" {
2980 pub fn capeCleanup();
2981}
2982unsafe extern "C" {
2983 pub fn capeGenerateUUID() -> CapeUUID;
2984}
2985unsafe extern "C" {
2986 pub fn capeUUIDFromString(str_: *const CapeCharacter, res: *mut CapeUUID) -> CapeResult;
2987}
2988unsafe extern "C" {
2989 pub fn capeStringFromUUID(uuid: *const CapeUUID, res: *mut ICapeString) -> CapeResult;
2990}
2991unsafe extern "C" {
2992 pub fn capeGetCobiaLanguage(res: *mut ICapeString) -> CapeResult;
2993}
2994unsafe extern "C" {
2995 pub fn capeGetCobiaVersion(res: *mut ICapeString) -> CapeResult;
2996}
2997unsafe extern "C" {
2998 pub fn capeGetCOBIAFolder(res: *mut ICapeString) -> CapeResult;
2999}
3000unsafe extern "C" {
3001 pub fn capeGetCOBIADataFolder(res: *mut ICapeString) -> CapeResult;
3002}
3003unsafe extern "C" {
3004 pub fn capeGetCOBIAUserDataFolder(res: *mut ICapeString) -> CapeResult;
3005}
3006unsafe extern "C" {
3007 pub fn capeGetErrorDescription(errorCode: CapeResult, res: *mut ICapeString) -> CapeResult;
3008}
3009unsafe extern "C" {
3010 pub fn capeCreatePMCInstance(
3011 uuid: *const CapeUUID,
3012 flags: CapePMCCreationFlags,
3013 res: *mut ICapeInterface,
3014 ) -> CapeResult;
3015}
3016unsafe extern "C" {
3017 pub fn capeGetRegistryKey(
3018 keyName: *const CapeCharacter,
3019 key: *mut *mut ICapeRegistryKey,
3020 ) -> CapeResult;
3021}
3022unsafe extern "C" {
3023 pub fn capeGetRegistryWriter(
3024 allUsers: bool,
3025 writer: *mut *mut ICapeRegistryWriter,
3026 ) -> CapeResult;
3027}
3028unsafe extern "C" {
3029 pub fn capeGetPMCEnumerator(pmcEnumerator: *mut *mut ICapePMCEnumerator) -> CapeResult;
3030}
3031unsafe extern "C" {
3032 pub fn capeGetLibraryEnumerator(
3033 libraryEnumerator: *mut *mut ICapeLibraryEnumerator,
3034 ) -> CapeResult;
3035}
3036unsafe extern "C" {
3037 pub fn cobiaDepersistFromTransitionFormat(
3038 reader: *mut ICapeInterface,
3039 transitionFormat: *mut *mut ICapeInterface,
3040 majorVersion: CapeInteger,
3041 minorVersion: CapeInteger,
3042 ) -> CapeResult;
3043}
3044unsafe extern "C" {
3045 pub fn cobiaDepersistPMCFromTransitionFormat(
3046 PMC: *mut ICapeInterface,
3047 reader: *mut ICapeInterface,
3048 majorVersion: CapeInteger,
3049 minorVersion: CapeInteger,
3050 ) -> CapeResult;
3051}
3052unsafe extern "C" {
3053 pub fn getCobiaDataClassFactories() -> *mut ICobiaDataClassFactory;
3054}
3055unsafe extern "C" {
3056 pub fn COBIAParseIDL(
3057 libraries: *mut ICapeArrayString,
3058 result: *mut *mut ICapeIDLParseResult,
3059 ) -> CapeResult;
3060}
3061unsafe extern "C" {
3062 pub static libraryId_CAPEOPEN: CapeUUID;
3063}
3064unsafe extern "C" {
3065 pub static categoryId_CAPEOPEN_UnitOperation: CapeUUID;
3066}
3067unsafe extern "C" {
3068 pub static categoryId_CAPEOPEN_PropertyPackageManager: CapeUUID;
3069}
3070unsafe extern "C" {
3071 pub static categoryId_CAPEOPEN_StandAlonePropertyPackage: CapeUUID;
3072}
3073unsafe extern "C" {
3074 pub static categoryId_CAPEOPEN_PhysicalPropertyCalculator: CapeUUID;
3075}
3076unsafe extern "C" {
3077 pub static categoryId_CAPEOPEN_EquilibriumCalculator: CapeUUID;
3078}
3079unsafe extern "C" {
3080 pub static categoryId_CAPEOPEN_FlowsheetMonitoringComponent: CapeUUID;
3081}
3082pub const eCAPEOPEN_1_2_CapeParamType_CAPE_PARAMETER_REAL: eCAPEOPEN_1_2_CapeParamType = 0;
3083pub const eCAPEOPEN_1_2_CapeParamType_CAPE_PARAMETER_INTEGER: eCAPEOPEN_1_2_CapeParamType = 1;
3084pub const eCAPEOPEN_1_2_CapeParamType_CAPE_PARAMETER_STRING: eCAPEOPEN_1_2_CapeParamType = 2;
3085pub const eCAPEOPEN_1_2_CapeParamType_CAPE_PARAMETER_BOOLEAN: eCAPEOPEN_1_2_CapeParamType = 3;
3086pub const eCAPEOPEN_1_2_CapeParamType_CAPE_PARAMETER_ARRAY_REAL: eCAPEOPEN_1_2_CapeParamType = 4;
3087pub const eCAPEOPEN_1_2_CapeParamType_CAPE_PARAMETER_ARRAY_INTEGER: eCAPEOPEN_1_2_CapeParamType = 5;
3088pub const eCAPEOPEN_1_2_CapeParamType_CAPE_PARAMETER_ARRAY_STRING: eCAPEOPEN_1_2_CapeParamType = 6;
3089pub const eCAPEOPEN_1_2_CapeParamType_CAPE_PARAMETER_ARRAY_BOOLEAN: eCAPEOPEN_1_2_CapeParamType = 7;
3090pub type eCAPEOPEN_1_2_CapeParamType = i32;
3091pub use self::eCAPEOPEN_1_2_CapeParamType as CAPEOPEN_1_2_CapeParamType;
3092pub const eCAPEOPEN_1_2_CapeDimensionality_CAPE_METER: eCAPEOPEN_1_2_CapeDimensionality = 0;
3093pub const eCAPEOPEN_1_2_CapeDimensionality_CAPE_KILOGRAM: eCAPEOPEN_1_2_CapeDimensionality = 1;
3094pub const eCAPEOPEN_1_2_CapeDimensionality_CAPE_SECOND: eCAPEOPEN_1_2_CapeDimensionality = 2;
3095pub const eCAPEOPEN_1_2_CapeDimensionality_CAPE_AMPERE: eCAPEOPEN_1_2_CapeDimensionality = 3;
3096pub const eCAPEOPEN_1_2_CapeDimensionality_CAPE_KELVIN: eCAPEOPEN_1_2_CapeDimensionality = 4;
3097pub const eCAPEOPEN_1_2_CapeDimensionality_CAPE_MOLE: eCAPEOPEN_1_2_CapeDimensionality = 5;
3098pub const eCAPEOPEN_1_2_CapeDimensionality_CAPE_CANDELA: eCAPEOPEN_1_2_CapeDimensionality = 6;
3099pub const eCAPEOPEN_1_2_CapeDimensionality_CAPE_RADIAN: eCAPEOPEN_1_2_CapeDimensionality = 7;
3100pub const eCAPEOPEN_1_2_CapeDimensionality_CAPE_DIFFERENCE_FLAG: eCAPEOPEN_1_2_CapeDimensionality =
3101 8;
3102pub const eCAPEOPEN_1_2_CapeDimensionality_CAPE_DIMENSIONALITY_LENGTH:
3103 eCAPEOPEN_1_2_CapeDimensionality = 9;
3104pub type eCAPEOPEN_1_2_CapeDimensionality = i32;
3105pub use self::eCAPEOPEN_1_2_CapeDimensionality as CAPEOPEN_1_2_CapeDimensionality;
3106pub const eCAPEOPEN_1_2_CapePersistedDataType_CAPE_PERSISTED_REAL:
3107 eCAPEOPEN_1_2_CapePersistedDataType = 0;
3108pub const eCAPEOPEN_1_2_CapePersistedDataType_CAPE_PERSISTED_INTEGER:
3109 eCAPEOPEN_1_2_CapePersistedDataType = 1;
3110pub const eCAPEOPEN_1_2_CapePersistedDataType_CAPE_PERSISTED_BOOLEAN:
3111 eCAPEOPEN_1_2_CapePersistedDataType = 2;
3112pub const eCAPEOPEN_1_2_CapePersistedDataType_CAPE_PERSISTED_STRING:
3113 eCAPEOPEN_1_2_CapePersistedDataType = 3;
3114pub const eCAPEOPEN_1_2_CapePersistedDataType_CAPE_PERSISTED_ENUMERATION:
3115 eCAPEOPEN_1_2_CapePersistedDataType = 4;
3116pub const eCAPEOPEN_1_2_CapePersistedDataType_CAPE_PERSISTED_VALUE:
3117 eCAPEOPEN_1_2_CapePersistedDataType = 5;
3118pub const eCAPEOPEN_1_2_CapePersistedDataType_CAPE_PERSISTED_ARRAY_REAL:
3119 eCAPEOPEN_1_2_CapePersistedDataType = 6;
3120pub const eCAPEOPEN_1_2_CapePersistedDataType_CAPE_PERSISTED_ARRAY_INTEGER:
3121 eCAPEOPEN_1_2_CapePersistedDataType = 7;
3122pub const eCAPEOPEN_1_2_CapePersistedDataType_CAPE_PERSISTED_ARRAY_BOOLEAN:
3123 eCAPEOPEN_1_2_CapePersistedDataType = 8;
3124pub const eCAPEOPEN_1_2_CapePersistedDataType_CAPE_PERSISTED_ARRAY_STRING:
3125 eCAPEOPEN_1_2_CapePersistedDataType = 9;
3126pub const eCAPEOPEN_1_2_CapePersistedDataType_CAPE_PERSISTED_ARRAY_ENUMERATION:
3127 eCAPEOPEN_1_2_CapePersistedDataType = 10;
3128pub const eCAPEOPEN_1_2_CapePersistedDataType_CAPE_PERSISTED_ARRAY_VALUE:
3129 eCAPEOPEN_1_2_CapePersistedDataType = 11;
3130pub const eCAPEOPEN_1_2_CapePersistedDataType_CAPE_PERSISTED_ARRAY_BYTE:
3131 eCAPEOPEN_1_2_CapePersistedDataType = 12;
3132pub type eCAPEOPEN_1_2_CapePersistedDataType = i32;
3133pub use self::eCAPEOPEN_1_2_CapePersistedDataType as CAPEOPEN_1_2_CapePersistedDataType;
3134pub const eCAPEOPEN_1_2_CapeParamMode_CAPE_INPUT: eCAPEOPEN_1_2_CapeParamMode = 1;
3135pub const eCAPEOPEN_1_2_CapeParamMode_CAPE_OUTPUT: eCAPEOPEN_1_2_CapeParamMode = 2;
3136pub const eCAPEOPEN_1_2_CapeParamMode_CAPE_INPUT_OUTPUT: eCAPEOPEN_1_2_CapeParamMode = 3;
3137pub type eCAPEOPEN_1_2_CapeParamMode = i32;
3138pub use self::eCAPEOPEN_1_2_CapeParamMode as CAPEOPEN_1_2_CapeParamMode;
3139pub const eCAPEOPEN_1_2_CapeValidationStatus_CAPE_NOT_VALIDATED:
3140 eCAPEOPEN_1_2_CapeValidationStatus = 0;
3141pub const eCAPEOPEN_1_2_CapeValidationStatus_CAPE_INVALID: eCAPEOPEN_1_2_CapeValidationStatus = 1;
3142pub const eCAPEOPEN_1_2_CapeValidationStatus_CAPE_VALID: eCAPEOPEN_1_2_CapeValidationStatus = 2;
3143pub type eCAPEOPEN_1_2_CapeValidationStatus = i32;
3144pub use self::eCAPEOPEN_1_2_CapeValidationStatus as CAPEOPEN_1_2_CapeValidationStatus;
3145pub const eCAPEOPEN_1_2_CapeCalculationCode_CAPE_NO_CALCULATION: eCAPEOPEN_1_2_CapeCalculationCode =
3146 0;
3147pub const eCAPEOPEN_1_2_CapeCalculationCode_CAPE_LOG_FUGACITY_COEFFICIENTS:
3148 eCAPEOPEN_1_2_CapeCalculationCode = 1;
3149pub const eCAPEOPEN_1_2_CapeCalculationCode_CAPE_T_DERIVATIVE: eCAPEOPEN_1_2_CapeCalculationCode =
3150 2;
3151pub const eCAPEOPEN_1_2_CapeCalculationCode_CAPE_P_DERIVATIVE: eCAPEOPEN_1_2_CapeCalculationCode =
3152 4;
3153pub const eCAPEOPEN_1_2_CapeCalculationCode_CAPE_MOLE_NUMBERS_DERIVATIVES:
3154 eCAPEOPEN_1_2_CapeCalculationCode = 8;
3155pub type eCAPEOPEN_1_2_CapeCalculationCode = i32;
3156pub use self::eCAPEOPEN_1_2_CapeCalculationCode as CAPEOPEN_1_2_CapeCalculationCode;
3157pub const eCAPEOPEN_1_2_CapePhaseStatus_CAPE_UNKNOWNPHASESTATUS: eCAPEOPEN_1_2_CapePhaseStatus = 0;
3158pub const eCAPEOPEN_1_2_CapePhaseStatus_CAPE_ATEQUILIBRIUM: eCAPEOPEN_1_2_CapePhaseStatus = 1;
3159pub const eCAPEOPEN_1_2_CapePhaseStatus_CAPE_ESTIMATES: eCAPEOPEN_1_2_CapePhaseStatus = 2;
3160pub type eCAPEOPEN_1_2_CapePhaseStatus = i32;
3161pub use self::eCAPEOPEN_1_2_CapePhaseStatus as CAPEOPEN_1_2_CapePhaseStatus;
3162pub const eCAPEOPEN_1_2_CapeEditResult_CAPE_MODIFIED: eCAPEOPEN_1_2_CapeEditResult = 0;
3163pub const eCAPEOPEN_1_2_CapeEditResult_CAPE_NOT_MODIFIED: eCAPEOPEN_1_2_CapeEditResult = 1;
3164pub type eCAPEOPEN_1_2_CapeEditResult = i32;
3165pub use self::eCAPEOPEN_1_2_CapeEditResult as CAPEOPEN_1_2_CapeEditResult;
3166pub const eCAPEOPEN_1_2_CapePortType_CAPE_MATERIAL: eCAPEOPEN_1_2_CapePortType = 0;
3167pub const eCAPEOPEN_1_2_CapePortType_CAPE_ENERGY: eCAPEOPEN_1_2_CapePortType = 1;
3168pub const eCAPEOPEN_1_2_CapePortType_CAPE_INFORMATION: eCAPEOPEN_1_2_CapePortType = 2;
3169pub const eCAPEOPEN_1_2_CapePortType_CAPE_ANY: eCAPEOPEN_1_2_CapePortType = 3;
3170pub type eCAPEOPEN_1_2_CapePortType = i32;
3171pub use self::eCAPEOPEN_1_2_CapePortType as CAPEOPEN_1_2_CapePortType;
3172pub const eCAPEOPEN_1_2_CapePortDirection_CAPE_INLET: eCAPEOPEN_1_2_CapePortDirection = 0;
3173pub const eCAPEOPEN_1_2_CapePortDirection_CAPE_OUTLET: eCAPEOPEN_1_2_CapePortDirection = 1;
3174pub const eCAPEOPEN_1_2_CapePortDirection_CAPE_INLET_OUTLET: eCAPEOPEN_1_2_CapePortDirection = 2;
3175pub type eCAPEOPEN_1_2_CapePortDirection = i32;
3176pub use self::eCAPEOPEN_1_2_CapePortDirection as CAPEOPEN_1_2_CapePortDirection;
3177pub const eCAPEOPEN_1_2_CapeSolutionStatus_CAPE_SOLVED: eCAPEOPEN_1_2_CapeSolutionStatus = 0;
3178pub const eCAPEOPEN_1_2_CapeSolutionStatus_CAPE_NOT_SOLVED: eCAPEOPEN_1_2_CapeSolutionStatus = 1;
3179pub type eCAPEOPEN_1_2_CapeSolutionStatus = i32;
3180pub use self::eCAPEOPEN_1_2_CapeSolutionStatus as CAPEOPEN_1_2_CapeSolutionStatus;
3181pub const eCAPEOPEN_1_2_CapeStreamType_CAPE_ANY_STREAMS: eCAPEOPEN_1_2_CapeStreamType = 0;
3182pub const eCAPEOPEN_1_2_CapeStreamType_CAPE_MATERIAL_STREAM: eCAPEOPEN_1_2_CapeStreamType = 1;
3183pub const eCAPEOPEN_1_2_CapeStreamType_CAPE_ENERGY_STREAM: eCAPEOPEN_1_2_CapeStreamType = 2;
3184pub const eCAPEOPEN_1_2_CapeStreamType_CAPE_INFORMATION_STREAM: eCAPEOPEN_1_2_CapeStreamType = 3;
3185pub type eCAPEOPEN_1_2_CapeStreamType = i32;
3186pub use self::eCAPEOPEN_1_2_CapeStreamType as CAPEOPEN_1_2_CapeStreamType;
3187pub const eCAPEOPEN_1_2_CapeMonitoringEvent_CAPE_UNIT_OPERATION_ADDED:
3188 eCAPEOPEN_1_2_CapeMonitoringEvent = 0;
3189pub const eCAPEOPEN_1_2_CapeMonitoringEvent_CAPE_UNIT_OPERATION_RENAMED:
3190 eCAPEOPEN_1_2_CapeMonitoringEvent = 1;
3191pub const eCAPEOPEN_1_2_CapeMonitoringEvent_CAPE_UNIT_OPERATION_REMOVED:
3192 eCAPEOPEN_1_2_CapeMonitoringEvent = 2;
3193pub const eCAPEOPEN_1_2_CapeMonitoringEvent_CAPE_STREAM_ADDED: eCAPEOPEN_1_2_CapeMonitoringEvent =
3194 3;
3195pub const eCAPEOPEN_1_2_CapeMonitoringEvent_CAPE_STREAM_RENAMED: eCAPEOPEN_1_2_CapeMonitoringEvent =
3196 4;
3197pub const eCAPEOPEN_1_2_CapeMonitoringEvent_CAPE_STREAM_REMOVED: eCAPEOPEN_1_2_CapeMonitoringEvent =
3198 5;
3199pub const eCAPEOPEN_1_2_CapeMonitoringEvent_CAPE_CONNECTION_CHANGED:
3200 eCAPEOPEN_1_2_CapeMonitoringEvent = 6;
3201pub const eCAPEOPEN_1_2_CapeMonitoringEvent_CAPE_FLOWSHEET_SOLUTION_STATUS_CHANGED:
3202 eCAPEOPEN_1_2_CapeMonitoringEvent = 7;
3203pub const eCAPEOPEN_1_2_CapeMonitoringEvent_CAPE_NEXT_TIME_STEP: eCAPEOPEN_1_2_CapeMonitoringEvent =
3204 8;
3205pub const eCAPEOPEN_1_2_CapeMonitoringEvent_CAPE_FLOWSHEET_VALIDATION_STATUS_CHANGED:
3206 eCAPEOPEN_1_2_CapeMonitoringEvent = 9;
3207pub type eCAPEOPEN_1_2_CapeMonitoringEvent = i32;
3208pub use self::eCAPEOPEN_1_2_CapeMonitoringEvent as CAPEOPEN_1_2_CapeMonitoringEvent;
3209#[repr(C)]
3210#[derive(Debug, Copy, Clone)]
3211pub struct CAPEOPEN_1_2_ICapeIdentification_VTable {
3212 pub base: ICapeInterface_VTable,
3213 pub getComponentName: ::std::option::Option<
3214 unsafe extern "C" fn(me: *mut ::std::os::raw::c_void, name: *mut ICapeString) -> CapeResult,
3215 >,
3216 pub putComponentName: ::std::option::Option<
3217 unsafe extern "C" fn(me: *mut ::std::os::raw::c_void, name: *mut ICapeString) -> CapeResult,
3218 >,
3219 pub getComponentDescription: ::std::option::Option<
3220 unsafe extern "C" fn(me: *mut ::std::os::raw::c_void, desc: *mut ICapeString) -> CapeResult,
3221 >,
3222 pub putComponentDescription: ::std::option::Option<
3223 unsafe extern "C" fn(me: *mut ::std::os::raw::c_void, desc: *mut ICapeString) -> CapeResult,
3224 >,
3225}
3226#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3227const _: () = {
3228 ["Size of CAPEOPEN_1_2_ICapeIdentification_VTable"]
3229 [::std::mem::size_of::<CAPEOPEN_1_2_ICapeIdentification_VTable>() - 64usize];
3230 ["Alignment of CAPEOPEN_1_2_ICapeIdentification_VTable"]
3231 [::std::mem::align_of::<CAPEOPEN_1_2_ICapeIdentification_VTable>() - 8usize];
3232 ["Offset of field: CAPEOPEN_1_2_ICapeIdentification_VTable::base"]
3233 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeIdentification_VTable, base) - 0usize];
3234 ["Offset of field: CAPEOPEN_1_2_ICapeIdentification_VTable::getComponentName"][::std::mem::offset_of!(
3235 CAPEOPEN_1_2_ICapeIdentification_VTable,
3236 getComponentName
3237 ) - 32usize];
3238 ["Offset of field: CAPEOPEN_1_2_ICapeIdentification_VTable::putComponentName"][::std::mem::offset_of!(
3239 CAPEOPEN_1_2_ICapeIdentification_VTable,
3240 putComponentName
3241 ) - 40usize];
3242 ["Offset of field: CAPEOPEN_1_2_ICapeIdentification_VTable::getComponentDescription"][::std::mem::offset_of!(
3243 CAPEOPEN_1_2_ICapeIdentification_VTable,
3244 getComponentDescription
3245 )
3246 - 48usize];
3247 ["Offset of field: CAPEOPEN_1_2_ICapeIdentification_VTable::putComponentDescription"][::std::mem::offset_of!(
3248 CAPEOPEN_1_2_ICapeIdentification_VTable,
3249 putComponentDescription
3250 )
3251 - 56usize];
3252};
3253#[repr(C)]
3254#[derive(Debug, Copy, Clone)]
3255pub struct _CAPEOPEN_1_2_ICapeIdentification {
3256 pub me: *mut ::std::os::raw::c_void,
3257 pub vTbl: *mut CAPEOPEN_1_2_ICapeIdentification_VTable,
3258}
3259#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3260const _: () = {
3261 ["Size of _CAPEOPEN_1_2_ICapeIdentification"]
3262 [::std::mem::size_of::<_CAPEOPEN_1_2_ICapeIdentification>() - 16usize];
3263 ["Alignment of _CAPEOPEN_1_2_ICapeIdentification"]
3264 [::std::mem::align_of::<_CAPEOPEN_1_2_ICapeIdentification>() - 8usize];
3265 ["Offset of field: _CAPEOPEN_1_2_ICapeIdentification::me"]
3266 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapeIdentification, me) - 0usize];
3267 ["Offset of field: _CAPEOPEN_1_2_ICapeIdentification::vTbl"]
3268 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapeIdentification, vTbl) - 8usize];
3269};
3270pub type CAPEOPEN_1_2_ICapeIdentification = _CAPEOPEN_1_2_ICapeIdentification;
3271#[repr(C)]
3272#[derive(Debug, Copy, Clone)]
3273pub struct CAPEOPEN_1_2_ICapeCollection_VTable {
3274 pub base: ICapeInterface_VTable,
3275 pub ItemByIndex: ::std::option::Option<
3276 unsafe extern "C" fn(
3277 me: *mut ::std::os::raw::c_void,
3278 index: CapeInteger,
3279 item: *mut *mut ICapeInterface,
3280 ) -> CapeResult,
3281 >,
3282 pub ItemByName: ::std::option::Option<
3283 unsafe extern "C" fn(
3284 me: *mut ::std::os::raw::c_void,
3285 name: *mut ICapeString,
3286 item: *mut *mut ICapeInterface,
3287 ) -> CapeResult,
3288 >,
3289 pub getCount: ::std::option::Option<
3290 unsafe extern "C" fn(
3291 me: *mut ::std::os::raw::c_void,
3292 itemCount: *mut CapeInteger,
3293 ) -> CapeResult,
3294 >,
3295}
3296#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3297const _: () = {
3298 ["Size of CAPEOPEN_1_2_ICapeCollection_VTable"]
3299 [::std::mem::size_of::<CAPEOPEN_1_2_ICapeCollection_VTable>() - 56usize];
3300 ["Alignment of CAPEOPEN_1_2_ICapeCollection_VTable"]
3301 [::std::mem::align_of::<CAPEOPEN_1_2_ICapeCollection_VTable>() - 8usize];
3302 ["Offset of field: CAPEOPEN_1_2_ICapeCollection_VTable::base"]
3303 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeCollection_VTable, base) - 0usize];
3304 ["Offset of field: CAPEOPEN_1_2_ICapeCollection_VTable::ItemByIndex"]
3305 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeCollection_VTable, ItemByIndex) - 32usize];
3306 ["Offset of field: CAPEOPEN_1_2_ICapeCollection_VTable::ItemByName"]
3307 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeCollection_VTable, ItemByName) - 40usize];
3308 ["Offset of field: CAPEOPEN_1_2_ICapeCollection_VTable::getCount"]
3309 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeCollection_VTable, getCount) - 48usize];
3310};
3311#[repr(C)]
3312#[derive(Debug, Copy, Clone)]
3313pub struct _CAPEOPEN_1_2_ICapeCollection {
3314 pub me: *mut ::std::os::raw::c_void,
3315 pub vTbl: *mut CAPEOPEN_1_2_ICapeCollection_VTable,
3316}
3317#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3318const _: () = {
3319 ["Size of _CAPEOPEN_1_2_ICapeCollection"]
3320 [::std::mem::size_of::<_CAPEOPEN_1_2_ICapeCollection>() - 16usize];
3321 ["Alignment of _CAPEOPEN_1_2_ICapeCollection"]
3322 [::std::mem::align_of::<_CAPEOPEN_1_2_ICapeCollection>() - 8usize];
3323 ["Offset of field: _CAPEOPEN_1_2_ICapeCollection::me"]
3324 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapeCollection, me) - 0usize];
3325 ["Offset of field: _CAPEOPEN_1_2_ICapeCollection::vTbl"]
3326 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapeCollection, vTbl) - 8usize];
3327};
3328pub type CAPEOPEN_1_2_ICapeCollection = _CAPEOPEN_1_2_ICapeCollection;
3329#[repr(C)]
3330#[derive(Debug, Copy, Clone)]
3331pub struct CAPEOPEN_1_2_ICapeParameter_VTable {
3332 pub base: ICapeInterface_VTable,
3333 pub getValStatus: ::std::option::Option<
3334 unsafe extern "C" fn(
3335 me: *mut ::std::os::raw::c_void,
3336 valStatus: *mut CAPEOPEN_1_2_CapeValidationStatus,
3337 ) -> CapeResult,
3338 >,
3339 pub getMode: ::std::option::Option<
3340 unsafe extern "C" fn(
3341 me: *mut ::std::os::raw::c_void,
3342 mode: *mut CAPEOPEN_1_2_CapeParamMode,
3343 ) -> CapeResult,
3344 >,
3345 pub getType: ::std::option::Option<
3346 unsafe extern "C" fn(
3347 me: *mut ::std::os::raw::c_void,
3348 parameterType: *mut CAPEOPEN_1_2_CapeParamType,
3349 ) -> CapeResult,
3350 >,
3351 pub Validate: ::std::option::Option<
3352 unsafe extern "C" fn(
3353 me: *mut ::std::os::raw::c_void,
3354 message: *mut ICapeString,
3355 isOK: *mut CapeBoolean,
3356 ) -> CapeResult,
3357 >,
3358 pub Reset:
3359 ::std::option::Option<unsafe extern "C" fn(me: *mut ::std::os::raw::c_void) -> CapeResult>,
3360}
3361#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3362const _: () = {
3363 ["Size of CAPEOPEN_1_2_ICapeParameter_VTable"]
3364 [::std::mem::size_of::<CAPEOPEN_1_2_ICapeParameter_VTable>() - 72usize];
3365 ["Alignment of CAPEOPEN_1_2_ICapeParameter_VTable"]
3366 [::std::mem::align_of::<CAPEOPEN_1_2_ICapeParameter_VTable>() - 8usize];
3367 ["Offset of field: CAPEOPEN_1_2_ICapeParameter_VTable::base"]
3368 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeParameter_VTable, base) - 0usize];
3369 ["Offset of field: CAPEOPEN_1_2_ICapeParameter_VTable::getValStatus"]
3370 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeParameter_VTable, getValStatus) - 32usize];
3371 ["Offset of field: CAPEOPEN_1_2_ICapeParameter_VTable::getMode"]
3372 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeParameter_VTable, getMode) - 40usize];
3373 ["Offset of field: CAPEOPEN_1_2_ICapeParameter_VTable::getType"]
3374 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeParameter_VTable, getType) - 48usize];
3375 ["Offset of field: CAPEOPEN_1_2_ICapeParameter_VTable::Validate"]
3376 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeParameter_VTable, Validate) - 56usize];
3377 ["Offset of field: CAPEOPEN_1_2_ICapeParameter_VTable::Reset"]
3378 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeParameter_VTable, Reset) - 64usize];
3379};
3380#[repr(C)]
3381#[derive(Debug, Copy, Clone)]
3382pub struct _CAPEOPEN_1_2_ICapeParameter {
3383 pub me: *mut ::std::os::raw::c_void,
3384 pub vTbl: *mut CAPEOPEN_1_2_ICapeParameter_VTable,
3385}
3386#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3387const _: () = {
3388 ["Size of _CAPEOPEN_1_2_ICapeParameter"]
3389 [::std::mem::size_of::<_CAPEOPEN_1_2_ICapeParameter>() - 16usize];
3390 ["Alignment of _CAPEOPEN_1_2_ICapeParameter"]
3391 [::std::mem::align_of::<_CAPEOPEN_1_2_ICapeParameter>() - 8usize];
3392 ["Offset of field: _CAPEOPEN_1_2_ICapeParameter::me"]
3393 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapeParameter, me) - 0usize];
3394 ["Offset of field: _CAPEOPEN_1_2_ICapeParameter::vTbl"]
3395 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapeParameter, vTbl) - 8usize];
3396};
3397pub type CAPEOPEN_1_2_ICapeParameter = _CAPEOPEN_1_2_ICapeParameter;
3398#[repr(C)]
3399#[derive(Debug, Copy, Clone)]
3400pub struct CAPEOPEN_1_2_ICapeRealParameter_VTable {
3401 pub base: ICapeInterface_VTable,
3402 pub getValue: ::std::option::Option<
3403 unsafe extern "C" fn(me: *mut ::std::os::raw::c_void, value: *mut CapeReal) -> CapeResult,
3404 >,
3405 pub putValue: ::std::option::Option<
3406 unsafe extern "C" fn(me: *mut ::std::os::raw::c_void, value: CapeReal) -> CapeResult,
3407 >,
3408 pub getDefaultValue: ::std::option::Option<
3409 unsafe extern "C" fn(
3410 me: *mut ::std::os::raw::c_void,
3411 defaultValue: *mut CapeReal,
3412 ) -> CapeResult,
3413 >,
3414 pub getLowerBound: ::std::option::Option<
3415 unsafe extern "C" fn(me: *mut ::std::os::raw::c_void, lBound: *mut CapeReal) -> CapeResult,
3416 >,
3417 pub getUpperBound: ::std::option::Option<
3418 unsafe extern "C" fn(me: *mut ::std::os::raw::c_void, uBound: *mut CapeReal) -> CapeResult,
3419 >,
3420 pub getDimensionality: ::std::option::Option<
3421 unsafe extern "C" fn(
3422 me: *mut ::std::os::raw::c_void,
3423 dimensionality: *mut ICapeArrayReal,
3424 ) -> CapeResult,
3425 >,
3426 pub Validate: ::std::option::Option<
3427 unsafe extern "C" fn(
3428 me: *mut ::std::os::raw::c_void,
3429 value: CapeReal,
3430 message: *mut ICapeString,
3431 isOK: *mut CapeBoolean,
3432 ) -> CapeResult,
3433 >,
3434}
3435#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3436const _: () = {
3437 ["Size of CAPEOPEN_1_2_ICapeRealParameter_VTable"]
3438 [::std::mem::size_of::<CAPEOPEN_1_2_ICapeRealParameter_VTable>() - 88usize];
3439 ["Alignment of CAPEOPEN_1_2_ICapeRealParameter_VTable"]
3440 [::std::mem::align_of::<CAPEOPEN_1_2_ICapeRealParameter_VTable>() - 8usize];
3441 ["Offset of field: CAPEOPEN_1_2_ICapeRealParameter_VTable::base"]
3442 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeRealParameter_VTable, base) - 0usize];
3443 ["Offset of field: CAPEOPEN_1_2_ICapeRealParameter_VTable::getValue"]
3444 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeRealParameter_VTable, getValue) - 32usize];
3445 ["Offset of field: CAPEOPEN_1_2_ICapeRealParameter_VTable::putValue"]
3446 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeRealParameter_VTable, putValue) - 40usize];
3447 ["Offset of field: CAPEOPEN_1_2_ICapeRealParameter_VTable::getDefaultValue"]
3448 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeRealParameter_VTable, getDefaultValue) - 48usize];
3449 ["Offset of field: CAPEOPEN_1_2_ICapeRealParameter_VTable::getLowerBound"]
3450 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeRealParameter_VTable, getLowerBound) - 56usize];
3451 ["Offset of field: CAPEOPEN_1_2_ICapeRealParameter_VTable::getUpperBound"]
3452 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeRealParameter_VTable, getUpperBound) - 64usize];
3453 ["Offset of field: CAPEOPEN_1_2_ICapeRealParameter_VTable::getDimensionality"][::std::mem::offset_of!(
3454 CAPEOPEN_1_2_ICapeRealParameter_VTable,
3455 getDimensionality
3456 ) - 72usize];
3457 ["Offset of field: CAPEOPEN_1_2_ICapeRealParameter_VTable::Validate"]
3458 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeRealParameter_VTable, Validate) - 80usize];
3459};
3460#[repr(C)]
3461#[derive(Debug, Copy, Clone)]
3462pub struct _CAPEOPEN_1_2_ICapeRealParameter {
3463 pub me: *mut ::std::os::raw::c_void,
3464 pub vTbl: *mut CAPEOPEN_1_2_ICapeRealParameter_VTable,
3465}
3466#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3467const _: () = {
3468 ["Size of _CAPEOPEN_1_2_ICapeRealParameter"]
3469 [::std::mem::size_of::<_CAPEOPEN_1_2_ICapeRealParameter>() - 16usize];
3470 ["Alignment of _CAPEOPEN_1_2_ICapeRealParameter"]
3471 [::std::mem::align_of::<_CAPEOPEN_1_2_ICapeRealParameter>() - 8usize];
3472 ["Offset of field: _CAPEOPEN_1_2_ICapeRealParameter::me"]
3473 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapeRealParameter, me) - 0usize];
3474 ["Offset of field: _CAPEOPEN_1_2_ICapeRealParameter::vTbl"]
3475 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapeRealParameter, vTbl) - 8usize];
3476};
3477pub type CAPEOPEN_1_2_ICapeRealParameter = _CAPEOPEN_1_2_ICapeRealParameter;
3478#[repr(C)]
3479#[derive(Debug, Copy, Clone)]
3480pub struct CAPEOPEN_1_2_ICapeIntegerParameter_VTable {
3481 pub base: ICapeInterface_VTable,
3482 pub getValue: ::std::option::Option<
3483 unsafe extern "C" fn(
3484 me: *mut ::std::os::raw::c_void,
3485 value: *mut CapeInteger,
3486 ) -> CapeResult,
3487 >,
3488 pub putValue: ::std::option::Option<
3489 unsafe extern "C" fn(me: *mut ::std::os::raw::c_void, value: CapeInteger) -> CapeResult,
3490 >,
3491 pub getDefaultValue: ::std::option::Option<
3492 unsafe extern "C" fn(
3493 me: *mut ::std::os::raw::c_void,
3494 defaultValue: *mut CapeInteger,
3495 ) -> CapeResult,
3496 >,
3497 pub getLowerBound: ::std::option::Option<
3498 unsafe extern "C" fn(
3499 me: *mut ::std::os::raw::c_void,
3500 lBound: *mut CapeInteger,
3501 ) -> CapeResult,
3502 >,
3503 pub getUpperBound: ::std::option::Option<
3504 unsafe extern "C" fn(
3505 me: *mut ::std::os::raw::c_void,
3506 uBound: *mut CapeInteger,
3507 ) -> CapeResult,
3508 >,
3509 pub Validate: ::std::option::Option<
3510 unsafe extern "C" fn(
3511 me: *mut ::std::os::raw::c_void,
3512 value: CapeInteger,
3513 message: *mut ICapeString,
3514 isOK: *mut CapeBoolean,
3515 ) -> CapeResult,
3516 >,
3517}
3518#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3519const _: () = {
3520 ["Size of CAPEOPEN_1_2_ICapeIntegerParameter_VTable"]
3521 [::std::mem::size_of::<CAPEOPEN_1_2_ICapeIntegerParameter_VTable>() - 80usize];
3522 ["Alignment of CAPEOPEN_1_2_ICapeIntegerParameter_VTable"]
3523 [::std::mem::align_of::<CAPEOPEN_1_2_ICapeIntegerParameter_VTable>() - 8usize];
3524 ["Offset of field: CAPEOPEN_1_2_ICapeIntegerParameter_VTable::base"]
3525 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeIntegerParameter_VTable, base) - 0usize];
3526 ["Offset of field: CAPEOPEN_1_2_ICapeIntegerParameter_VTable::getValue"]
3527 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeIntegerParameter_VTable, getValue) - 32usize];
3528 ["Offset of field: CAPEOPEN_1_2_ICapeIntegerParameter_VTable::putValue"]
3529 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeIntegerParameter_VTable, putValue) - 40usize];
3530 ["Offset of field: CAPEOPEN_1_2_ICapeIntegerParameter_VTable::getDefaultValue"][::std::mem::offset_of!(
3531 CAPEOPEN_1_2_ICapeIntegerParameter_VTable,
3532 getDefaultValue
3533 ) - 48usize];
3534 ["Offset of field: CAPEOPEN_1_2_ICapeIntegerParameter_VTable::getLowerBound"][::std::mem::offset_of!(
3535 CAPEOPEN_1_2_ICapeIntegerParameter_VTable,
3536 getLowerBound
3537 ) - 56usize];
3538 ["Offset of field: CAPEOPEN_1_2_ICapeIntegerParameter_VTable::getUpperBound"][::std::mem::offset_of!(
3539 CAPEOPEN_1_2_ICapeIntegerParameter_VTable,
3540 getUpperBound
3541 ) - 64usize];
3542 ["Offset of field: CAPEOPEN_1_2_ICapeIntegerParameter_VTable::Validate"]
3543 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeIntegerParameter_VTable, Validate) - 72usize];
3544};
3545#[repr(C)]
3546#[derive(Debug, Copy, Clone)]
3547pub struct _CAPEOPEN_1_2_ICapeIntegerParameter {
3548 pub me: *mut ::std::os::raw::c_void,
3549 pub vTbl: *mut CAPEOPEN_1_2_ICapeIntegerParameter_VTable,
3550}
3551#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3552const _: () = {
3553 ["Size of _CAPEOPEN_1_2_ICapeIntegerParameter"]
3554 [::std::mem::size_of::<_CAPEOPEN_1_2_ICapeIntegerParameter>() - 16usize];
3555 ["Alignment of _CAPEOPEN_1_2_ICapeIntegerParameter"]
3556 [::std::mem::align_of::<_CAPEOPEN_1_2_ICapeIntegerParameter>() - 8usize];
3557 ["Offset of field: _CAPEOPEN_1_2_ICapeIntegerParameter::me"]
3558 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapeIntegerParameter, me) - 0usize];
3559 ["Offset of field: _CAPEOPEN_1_2_ICapeIntegerParameter::vTbl"]
3560 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapeIntegerParameter, vTbl) - 8usize];
3561};
3562pub type CAPEOPEN_1_2_ICapeIntegerParameter = _CAPEOPEN_1_2_ICapeIntegerParameter;
3563#[repr(C)]
3564#[derive(Debug, Copy, Clone)]
3565pub struct CAPEOPEN_1_2_ICapeStringParameter_VTable {
3566 pub base: ICapeInterface_VTable,
3567 pub getValue: ::std::option::Option<
3568 unsafe extern "C" fn(
3569 me: *mut ::std::os::raw::c_void,
3570 value: *mut ICapeString,
3571 ) -> CapeResult,
3572 >,
3573 pub putValue: ::std::option::Option<
3574 unsafe extern "C" fn(
3575 me: *mut ::std::os::raw::c_void,
3576 value: *mut ICapeString,
3577 ) -> CapeResult,
3578 >,
3579 pub getDefaultValue: ::std::option::Option<
3580 unsafe extern "C" fn(
3581 me: *mut ::std::os::raw::c_void,
3582 defaultValue: *mut ICapeString,
3583 ) -> CapeResult,
3584 >,
3585 pub getOptionList: ::std::option::Option<
3586 unsafe extern "C" fn(
3587 me: *mut ::std::os::raw::c_void,
3588 optionNames: *mut ICapeArrayString,
3589 ) -> CapeResult,
3590 >,
3591 pub getRestrictedToList: ::std::option::Option<
3592 unsafe extern "C" fn(
3593 me: *mut ::std::os::raw::c_void,
3594 restricted: *mut CapeBoolean,
3595 ) -> CapeResult,
3596 >,
3597 pub Validate: ::std::option::Option<
3598 unsafe extern "C" fn(
3599 me: *mut ::std::os::raw::c_void,
3600 value: *mut ICapeString,
3601 message: *mut ICapeString,
3602 isOK: *mut CapeBoolean,
3603 ) -> CapeResult,
3604 >,
3605}
3606#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3607const _: () = {
3608 ["Size of CAPEOPEN_1_2_ICapeStringParameter_VTable"]
3609 [::std::mem::size_of::<CAPEOPEN_1_2_ICapeStringParameter_VTable>() - 80usize];
3610 ["Alignment of CAPEOPEN_1_2_ICapeStringParameter_VTable"]
3611 [::std::mem::align_of::<CAPEOPEN_1_2_ICapeStringParameter_VTable>() - 8usize];
3612 ["Offset of field: CAPEOPEN_1_2_ICapeStringParameter_VTable::base"]
3613 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeStringParameter_VTable, base) - 0usize];
3614 ["Offset of field: CAPEOPEN_1_2_ICapeStringParameter_VTable::getValue"]
3615 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeStringParameter_VTable, getValue) - 32usize];
3616 ["Offset of field: CAPEOPEN_1_2_ICapeStringParameter_VTable::putValue"]
3617 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeStringParameter_VTable, putValue) - 40usize];
3618 ["Offset of field: CAPEOPEN_1_2_ICapeStringParameter_VTable::getDefaultValue"][::std::mem::offset_of!(
3619 CAPEOPEN_1_2_ICapeStringParameter_VTable,
3620 getDefaultValue
3621 ) - 48usize];
3622 ["Offset of field: CAPEOPEN_1_2_ICapeStringParameter_VTable::getOptionList"]
3623 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeStringParameter_VTable, getOptionList) - 56usize];
3624 ["Offset of field: CAPEOPEN_1_2_ICapeStringParameter_VTable::getRestrictedToList"][::std::mem::offset_of!(
3625 CAPEOPEN_1_2_ICapeStringParameter_VTable,
3626 getRestrictedToList
3627 ) - 64usize];
3628 ["Offset of field: CAPEOPEN_1_2_ICapeStringParameter_VTable::Validate"]
3629 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeStringParameter_VTable, Validate) - 72usize];
3630};
3631#[repr(C)]
3632#[derive(Debug, Copy, Clone)]
3633pub struct _CAPEOPEN_1_2_ICapeStringParameter {
3634 pub me: *mut ::std::os::raw::c_void,
3635 pub vTbl: *mut CAPEOPEN_1_2_ICapeStringParameter_VTable,
3636}
3637#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3638const _: () = {
3639 ["Size of _CAPEOPEN_1_2_ICapeStringParameter"]
3640 [::std::mem::size_of::<_CAPEOPEN_1_2_ICapeStringParameter>() - 16usize];
3641 ["Alignment of _CAPEOPEN_1_2_ICapeStringParameter"]
3642 [::std::mem::align_of::<_CAPEOPEN_1_2_ICapeStringParameter>() - 8usize];
3643 ["Offset of field: _CAPEOPEN_1_2_ICapeStringParameter::me"]
3644 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapeStringParameter, me) - 0usize];
3645 ["Offset of field: _CAPEOPEN_1_2_ICapeStringParameter::vTbl"]
3646 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapeStringParameter, vTbl) - 8usize];
3647};
3648pub type CAPEOPEN_1_2_ICapeStringParameter = _CAPEOPEN_1_2_ICapeStringParameter;
3649#[repr(C)]
3650#[derive(Debug, Copy, Clone)]
3651pub struct CAPEOPEN_1_2_ICapeBooleanParameter_VTable {
3652 pub base: ICapeInterface_VTable,
3653 pub getValue: ::std::option::Option<
3654 unsafe extern "C" fn(
3655 me: *mut ::std::os::raw::c_void,
3656 value: *mut CapeBoolean,
3657 ) -> CapeResult,
3658 >,
3659 pub putValue: ::std::option::Option<
3660 unsafe extern "C" fn(me: *mut ::std::os::raw::c_void, value: CapeBoolean) -> CapeResult,
3661 >,
3662 pub getDefaultValue: ::std::option::Option<
3663 unsafe extern "C" fn(
3664 me: *mut ::std::os::raw::c_void,
3665 defaultValue: *mut CapeBoolean,
3666 ) -> CapeResult,
3667 >,
3668 pub Validate: ::std::option::Option<
3669 unsafe extern "C" fn(
3670 me: *mut ::std::os::raw::c_void,
3671 value: CapeBoolean,
3672 message: *mut ICapeString,
3673 isOK: *mut CapeBoolean,
3674 ) -> CapeResult,
3675 >,
3676}
3677#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3678const _: () = {
3679 ["Size of CAPEOPEN_1_2_ICapeBooleanParameter_VTable"]
3680 [::std::mem::size_of::<CAPEOPEN_1_2_ICapeBooleanParameter_VTable>() - 64usize];
3681 ["Alignment of CAPEOPEN_1_2_ICapeBooleanParameter_VTable"]
3682 [::std::mem::align_of::<CAPEOPEN_1_2_ICapeBooleanParameter_VTable>() - 8usize];
3683 ["Offset of field: CAPEOPEN_1_2_ICapeBooleanParameter_VTable::base"]
3684 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeBooleanParameter_VTable, base) - 0usize];
3685 ["Offset of field: CAPEOPEN_1_2_ICapeBooleanParameter_VTable::getValue"]
3686 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeBooleanParameter_VTable, getValue) - 32usize];
3687 ["Offset of field: CAPEOPEN_1_2_ICapeBooleanParameter_VTable::putValue"]
3688 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeBooleanParameter_VTable, putValue) - 40usize];
3689 ["Offset of field: CAPEOPEN_1_2_ICapeBooleanParameter_VTable::getDefaultValue"][::std::mem::offset_of!(
3690 CAPEOPEN_1_2_ICapeBooleanParameter_VTable,
3691 getDefaultValue
3692 ) - 48usize];
3693 ["Offset of field: CAPEOPEN_1_2_ICapeBooleanParameter_VTable::Validate"]
3694 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeBooleanParameter_VTable, Validate) - 56usize];
3695};
3696#[repr(C)]
3697#[derive(Debug, Copy, Clone)]
3698pub struct _CAPEOPEN_1_2_ICapeBooleanParameter {
3699 pub me: *mut ::std::os::raw::c_void,
3700 pub vTbl: *mut CAPEOPEN_1_2_ICapeBooleanParameter_VTable,
3701}
3702#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3703const _: () = {
3704 ["Size of _CAPEOPEN_1_2_ICapeBooleanParameter"]
3705 [::std::mem::size_of::<_CAPEOPEN_1_2_ICapeBooleanParameter>() - 16usize];
3706 ["Alignment of _CAPEOPEN_1_2_ICapeBooleanParameter"]
3707 [::std::mem::align_of::<_CAPEOPEN_1_2_ICapeBooleanParameter>() - 8usize];
3708 ["Offset of field: _CAPEOPEN_1_2_ICapeBooleanParameter::me"]
3709 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapeBooleanParameter, me) - 0usize];
3710 ["Offset of field: _CAPEOPEN_1_2_ICapeBooleanParameter::vTbl"]
3711 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapeBooleanParameter, vTbl) - 8usize];
3712};
3713pub type CAPEOPEN_1_2_ICapeBooleanParameter = _CAPEOPEN_1_2_ICapeBooleanParameter;
3714#[repr(C)]
3715#[derive(Debug, Copy, Clone)]
3716pub struct CAPEOPEN_1_2_ICapeArrayParameter_VTable {
3717 pub base: ICapeInterface_VTable,
3718 pub getNumDimensions: ::std::option::Option<
3719 unsafe extern "C" fn(
3720 me: *mut ::std::os::raw::c_void,
3721 numDimensions: *mut CapeInteger,
3722 ) -> CapeResult,
3723 >,
3724 pub getSize: ::std::option::Option<
3725 unsafe extern "C" fn(
3726 me: *mut ::std::os::raw::c_void,
3727 size: *mut ICapeArrayInteger,
3728 ) -> CapeResult,
3729 >,
3730}
3731#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3732const _: () = {
3733 ["Size of CAPEOPEN_1_2_ICapeArrayParameter_VTable"]
3734 [::std::mem::size_of::<CAPEOPEN_1_2_ICapeArrayParameter_VTable>() - 48usize];
3735 ["Alignment of CAPEOPEN_1_2_ICapeArrayParameter_VTable"]
3736 [::std::mem::align_of::<CAPEOPEN_1_2_ICapeArrayParameter_VTable>() - 8usize];
3737 ["Offset of field: CAPEOPEN_1_2_ICapeArrayParameter_VTable::base"]
3738 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeArrayParameter_VTable, base) - 0usize];
3739 ["Offset of field: CAPEOPEN_1_2_ICapeArrayParameter_VTable::getNumDimensions"][::std::mem::offset_of!(
3740 CAPEOPEN_1_2_ICapeArrayParameter_VTable,
3741 getNumDimensions
3742 ) - 32usize];
3743 ["Offset of field: CAPEOPEN_1_2_ICapeArrayParameter_VTable::getSize"]
3744 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeArrayParameter_VTable, getSize) - 40usize];
3745};
3746#[repr(C)]
3747#[derive(Debug, Copy, Clone)]
3748pub struct _CAPEOPEN_1_2_ICapeArrayParameter {
3749 pub me: *mut ::std::os::raw::c_void,
3750 pub vTbl: *mut CAPEOPEN_1_2_ICapeArrayParameter_VTable,
3751}
3752#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3753const _: () = {
3754 ["Size of _CAPEOPEN_1_2_ICapeArrayParameter"]
3755 [::std::mem::size_of::<_CAPEOPEN_1_2_ICapeArrayParameter>() - 16usize];
3756 ["Alignment of _CAPEOPEN_1_2_ICapeArrayParameter"]
3757 [::std::mem::align_of::<_CAPEOPEN_1_2_ICapeArrayParameter>() - 8usize];
3758 ["Offset of field: _CAPEOPEN_1_2_ICapeArrayParameter::me"]
3759 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapeArrayParameter, me) - 0usize];
3760 ["Offset of field: _CAPEOPEN_1_2_ICapeArrayParameter::vTbl"]
3761 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapeArrayParameter, vTbl) - 8usize];
3762};
3763pub type CAPEOPEN_1_2_ICapeArrayParameter = _CAPEOPEN_1_2_ICapeArrayParameter;
3764#[repr(C)]
3765#[derive(Debug, Copy, Clone)]
3766pub struct CAPEOPEN_1_2_ICapeArrayRealParameter_VTable {
3767 pub base: ICapeInterface_VTable,
3768 pub getValue: ::std::option::Option<
3769 unsafe extern "C" fn(
3770 me: *mut ::std::os::raw::c_void,
3771 value: *mut ICapeArrayReal,
3772 ) -> CapeResult,
3773 >,
3774 pub putValue: ::std::option::Option<
3775 unsafe extern "C" fn(
3776 me: *mut ::std::os::raw::c_void,
3777 value: *mut ICapeArrayReal,
3778 ) -> CapeResult,
3779 >,
3780 pub GetElementValue: ::std::option::Option<
3781 unsafe extern "C" fn(
3782 me: *mut ::std::os::raw::c_void,
3783 position: *mut ICapeArrayInteger,
3784 value: *mut CapeReal,
3785 ) -> CapeResult,
3786 >,
3787 pub SetElementValue: ::std::option::Option<
3788 unsafe extern "C" fn(
3789 me: *mut ::std::os::raw::c_void,
3790 position: *mut ICapeArrayInteger,
3791 value: CapeReal,
3792 ) -> CapeResult,
3793 >,
3794 pub getDefaultValue: ::std::option::Option<
3795 unsafe extern "C" fn(
3796 me: *mut ::std::os::raw::c_void,
3797 defaultValue: *mut CapeReal,
3798 ) -> CapeResult,
3799 >,
3800 pub getLowerBound: ::std::option::Option<
3801 unsafe extern "C" fn(me: *mut ::std::os::raw::c_void, lBound: *mut CapeReal) -> CapeResult,
3802 >,
3803 pub getUpperBound: ::std::option::Option<
3804 unsafe extern "C" fn(me: *mut ::std::os::raw::c_void, uBound: *mut CapeReal) -> CapeResult,
3805 >,
3806 pub getDimensionality: ::std::option::Option<
3807 unsafe extern "C" fn(
3808 me: *mut ::std::os::raw::c_void,
3809 dimensionality: *mut ICapeArrayReal,
3810 ) -> CapeResult,
3811 >,
3812 pub ValidateElement: ::std::option::Option<
3813 unsafe extern "C" fn(
3814 me: *mut ::std::os::raw::c_void,
3815 position: *mut ICapeArrayInteger,
3816 value: CapeReal,
3817 message: *mut ICapeString,
3818 isOK: *mut CapeBoolean,
3819 ) -> CapeResult,
3820 >,
3821 pub Validate: ::std::option::Option<
3822 unsafe extern "C" fn(
3823 me: *mut ::std::os::raw::c_void,
3824 value: *mut ICapeArrayReal,
3825 message: *mut ICapeString,
3826 isOK: *mut CapeBoolean,
3827 ) -> CapeResult,
3828 >,
3829}
3830#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3831const _: () = {
3832 ["Size of CAPEOPEN_1_2_ICapeArrayRealParameter_VTable"]
3833 [::std::mem::size_of::<CAPEOPEN_1_2_ICapeArrayRealParameter_VTable>() - 112usize];
3834 ["Alignment of CAPEOPEN_1_2_ICapeArrayRealParameter_VTable"]
3835 [::std::mem::align_of::<CAPEOPEN_1_2_ICapeArrayRealParameter_VTable>() - 8usize];
3836 ["Offset of field: CAPEOPEN_1_2_ICapeArrayRealParameter_VTable::base"]
3837 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeArrayRealParameter_VTable, base) - 0usize];
3838 ["Offset of field: CAPEOPEN_1_2_ICapeArrayRealParameter_VTable::getValue"]
3839 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeArrayRealParameter_VTable, getValue) - 32usize];
3840 ["Offset of field: CAPEOPEN_1_2_ICapeArrayRealParameter_VTable::putValue"]
3841 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeArrayRealParameter_VTable, putValue) - 40usize];
3842 ["Offset of field: CAPEOPEN_1_2_ICapeArrayRealParameter_VTable::GetElementValue"][::std::mem::offset_of!(
3843 CAPEOPEN_1_2_ICapeArrayRealParameter_VTable,
3844 GetElementValue
3845 ) - 48usize];
3846 ["Offset of field: CAPEOPEN_1_2_ICapeArrayRealParameter_VTable::SetElementValue"][::std::mem::offset_of!(
3847 CAPEOPEN_1_2_ICapeArrayRealParameter_VTable,
3848 SetElementValue
3849 ) - 56usize];
3850 ["Offset of field: CAPEOPEN_1_2_ICapeArrayRealParameter_VTable::getDefaultValue"][::std::mem::offset_of!(
3851 CAPEOPEN_1_2_ICapeArrayRealParameter_VTable,
3852 getDefaultValue
3853 ) - 64usize];
3854 ["Offset of field: CAPEOPEN_1_2_ICapeArrayRealParameter_VTable::getLowerBound"][::std::mem::offset_of!(
3855 CAPEOPEN_1_2_ICapeArrayRealParameter_VTable,
3856 getLowerBound
3857 ) - 72usize];
3858 ["Offset of field: CAPEOPEN_1_2_ICapeArrayRealParameter_VTable::getUpperBound"][::std::mem::offset_of!(
3859 CAPEOPEN_1_2_ICapeArrayRealParameter_VTable,
3860 getUpperBound
3861 ) - 80usize];
3862 ["Offset of field: CAPEOPEN_1_2_ICapeArrayRealParameter_VTable::getDimensionality"][::std::mem::offset_of!(
3863 CAPEOPEN_1_2_ICapeArrayRealParameter_VTable,
3864 getDimensionality
3865 )
3866 - 88usize];
3867 ["Offset of field: CAPEOPEN_1_2_ICapeArrayRealParameter_VTable::ValidateElement"][::std::mem::offset_of!(
3868 CAPEOPEN_1_2_ICapeArrayRealParameter_VTable,
3869 ValidateElement
3870 ) - 96usize];
3871 ["Offset of field: CAPEOPEN_1_2_ICapeArrayRealParameter_VTable::Validate"]
3872 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeArrayRealParameter_VTable, Validate) - 104usize];
3873};
3874#[repr(C)]
3875#[derive(Debug, Copy, Clone)]
3876pub struct _CAPEOPEN_1_2_ICapeArrayRealParameter {
3877 pub me: *mut ::std::os::raw::c_void,
3878 pub vTbl: *mut CAPEOPEN_1_2_ICapeArrayRealParameter_VTable,
3879}
3880#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3881const _: () = {
3882 ["Size of _CAPEOPEN_1_2_ICapeArrayRealParameter"]
3883 [::std::mem::size_of::<_CAPEOPEN_1_2_ICapeArrayRealParameter>() - 16usize];
3884 ["Alignment of _CAPEOPEN_1_2_ICapeArrayRealParameter"]
3885 [::std::mem::align_of::<_CAPEOPEN_1_2_ICapeArrayRealParameter>() - 8usize];
3886 ["Offset of field: _CAPEOPEN_1_2_ICapeArrayRealParameter::me"]
3887 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapeArrayRealParameter, me) - 0usize];
3888 ["Offset of field: _CAPEOPEN_1_2_ICapeArrayRealParameter::vTbl"]
3889 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapeArrayRealParameter, vTbl) - 8usize];
3890};
3891pub type CAPEOPEN_1_2_ICapeArrayRealParameter = _CAPEOPEN_1_2_ICapeArrayRealParameter;
3892#[repr(C)]
3893#[derive(Debug, Copy, Clone)]
3894pub struct CAPEOPEN_1_2_ICapeArrayIntegerParameter_VTable {
3895 pub base: ICapeInterface_VTable,
3896 pub getValue: ::std::option::Option<
3897 unsafe extern "C" fn(
3898 me: *mut ::std::os::raw::c_void,
3899 value: *mut ICapeArrayInteger,
3900 ) -> CapeResult,
3901 >,
3902 pub putValue: ::std::option::Option<
3903 unsafe extern "C" fn(
3904 me: *mut ::std::os::raw::c_void,
3905 value: *mut ICapeArrayInteger,
3906 ) -> CapeResult,
3907 >,
3908 pub GetElementValue: ::std::option::Option<
3909 unsafe extern "C" fn(
3910 me: *mut ::std::os::raw::c_void,
3911 position: *mut ICapeArrayInteger,
3912 value: *mut CapeInteger,
3913 ) -> CapeResult,
3914 >,
3915 pub SetElementValue: ::std::option::Option<
3916 unsafe extern "C" fn(
3917 me: *mut ::std::os::raw::c_void,
3918 position: *mut ICapeArrayInteger,
3919 value: CapeInteger,
3920 ) -> CapeResult,
3921 >,
3922 pub getDefaultValue: ::std::option::Option<
3923 unsafe extern "C" fn(
3924 me: *mut ::std::os::raw::c_void,
3925 defaultValue: *mut CapeInteger,
3926 ) -> CapeResult,
3927 >,
3928 pub getLowerBound: ::std::option::Option<
3929 unsafe extern "C" fn(
3930 me: *mut ::std::os::raw::c_void,
3931 lBound: *mut CapeInteger,
3932 ) -> CapeResult,
3933 >,
3934 pub getUpperBound: ::std::option::Option<
3935 unsafe extern "C" fn(
3936 me: *mut ::std::os::raw::c_void,
3937 uBound: *mut CapeInteger,
3938 ) -> CapeResult,
3939 >,
3940 pub ValidateElement: ::std::option::Option<
3941 unsafe extern "C" fn(
3942 me: *mut ::std::os::raw::c_void,
3943 position: *mut ICapeArrayInteger,
3944 value: CapeInteger,
3945 message: *mut ICapeString,
3946 isOK: *mut CapeBoolean,
3947 ) -> CapeResult,
3948 >,
3949 pub Validate: ::std::option::Option<
3950 unsafe extern "C" fn(
3951 me: *mut ::std::os::raw::c_void,
3952 value: *mut ICapeArrayInteger,
3953 message: *mut ICapeString,
3954 isOK: *mut CapeBoolean,
3955 ) -> CapeResult,
3956 >,
3957}
3958#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3959const _: () = {
3960 ["Size of CAPEOPEN_1_2_ICapeArrayIntegerParameter_VTable"]
3961 [::std::mem::size_of::<CAPEOPEN_1_2_ICapeArrayIntegerParameter_VTable>() - 104usize];
3962 ["Alignment of CAPEOPEN_1_2_ICapeArrayIntegerParameter_VTable"]
3963 [::std::mem::align_of::<CAPEOPEN_1_2_ICapeArrayIntegerParameter_VTable>() - 8usize];
3964 ["Offset of field: CAPEOPEN_1_2_ICapeArrayIntegerParameter_VTable::base"]
3965 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeArrayIntegerParameter_VTable, base) - 0usize];
3966 ["Offset of field: CAPEOPEN_1_2_ICapeArrayIntegerParameter_VTable::getValue"][::std::mem::offset_of!(
3967 CAPEOPEN_1_2_ICapeArrayIntegerParameter_VTable,
3968 getValue
3969 ) - 32usize];
3970 ["Offset of field: CAPEOPEN_1_2_ICapeArrayIntegerParameter_VTable::putValue"][::std::mem::offset_of!(
3971 CAPEOPEN_1_2_ICapeArrayIntegerParameter_VTable,
3972 putValue
3973 ) - 40usize];
3974 ["Offset of field: CAPEOPEN_1_2_ICapeArrayIntegerParameter_VTable::GetElementValue"][::std::mem::offset_of!(
3975 CAPEOPEN_1_2_ICapeArrayIntegerParameter_VTable,
3976 GetElementValue
3977 )
3978 - 48usize];
3979 ["Offset of field: CAPEOPEN_1_2_ICapeArrayIntegerParameter_VTable::SetElementValue"][::std::mem::offset_of!(
3980 CAPEOPEN_1_2_ICapeArrayIntegerParameter_VTable,
3981 SetElementValue
3982 )
3983 - 56usize];
3984 ["Offset of field: CAPEOPEN_1_2_ICapeArrayIntegerParameter_VTable::getDefaultValue"][::std::mem::offset_of!(
3985 CAPEOPEN_1_2_ICapeArrayIntegerParameter_VTable,
3986 getDefaultValue
3987 )
3988 - 64usize];
3989 ["Offset of field: CAPEOPEN_1_2_ICapeArrayIntegerParameter_VTable::getLowerBound"][::std::mem::offset_of!(
3990 CAPEOPEN_1_2_ICapeArrayIntegerParameter_VTable,
3991 getLowerBound
3992 ) - 72usize];
3993 ["Offset of field: CAPEOPEN_1_2_ICapeArrayIntegerParameter_VTable::getUpperBound"][::std::mem::offset_of!(
3994 CAPEOPEN_1_2_ICapeArrayIntegerParameter_VTable,
3995 getUpperBound
3996 ) - 80usize];
3997 ["Offset of field: CAPEOPEN_1_2_ICapeArrayIntegerParameter_VTable::ValidateElement"][::std::mem::offset_of!(
3998 CAPEOPEN_1_2_ICapeArrayIntegerParameter_VTable,
3999 ValidateElement
4000 )
4001 - 88usize];
4002 ["Offset of field: CAPEOPEN_1_2_ICapeArrayIntegerParameter_VTable::Validate"][::std::mem::offset_of!(
4003 CAPEOPEN_1_2_ICapeArrayIntegerParameter_VTable,
4004 Validate
4005 ) - 96usize];
4006};
4007#[repr(C)]
4008#[derive(Debug, Copy, Clone)]
4009pub struct _CAPEOPEN_1_2_ICapeArrayIntegerParameter {
4010 pub me: *mut ::std::os::raw::c_void,
4011 pub vTbl: *mut CAPEOPEN_1_2_ICapeArrayIntegerParameter_VTable,
4012}
4013#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4014const _: () = {
4015 ["Size of _CAPEOPEN_1_2_ICapeArrayIntegerParameter"]
4016 [::std::mem::size_of::<_CAPEOPEN_1_2_ICapeArrayIntegerParameter>() - 16usize];
4017 ["Alignment of _CAPEOPEN_1_2_ICapeArrayIntegerParameter"]
4018 [::std::mem::align_of::<_CAPEOPEN_1_2_ICapeArrayIntegerParameter>() - 8usize];
4019 ["Offset of field: _CAPEOPEN_1_2_ICapeArrayIntegerParameter::me"]
4020 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapeArrayIntegerParameter, me) - 0usize];
4021 ["Offset of field: _CAPEOPEN_1_2_ICapeArrayIntegerParameter::vTbl"]
4022 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapeArrayIntegerParameter, vTbl) - 8usize];
4023};
4024pub type CAPEOPEN_1_2_ICapeArrayIntegerParameter = _CAPEOPEN_1_2_ICapeArrayIntegerParameter;
4025#[repr(C)]
4026#[derive(Debug, Copy, Clone)]
4027pub struct CAPEOPEN_1_2_ICapeArrayStringParameter_VTable {
4028 pub base: ICapeInterface_VTable,
4029 pub getValue: ::std::option::Option<
4030 unsafe extern "C" fn(
4031 me: *mut ::std::os::raw::c_void,
4032 value: *mut ICapeArrayString,
4033 ) -> CapeResult,
4034 >,
4035 pub putValue: ::std::option::Option<
4036 unsafe extern "C" fn(
4037 me: *mut ::std::os::raw::c_void,
4038 value: *mut ICapeArrayString,
4039 ) -> CapeResult,
4040 >,
4041 pub GetElementValue: ::std::option::Option<
4042 unsafe extern "C" fn(
4043 me: *mut ::std::os::raw::c_void,
4044 position: *mut ICapeArrayInteger,
4045 value: *mut ICapeString,
4046 ) -> CapeResult,
4047 >,
4048 pub SetElementValue: ::std::option::Option<
4049 unsafe extern "C" fn(
4050 me: *mut ::std::os::raw::c_void,
4051 position: *mut ICapeArrayInteger,
4052 value: *mut ICapeString,
4053 ) -> CapeResult,
4054 >,
4055 pub getDefaultValue: ::std::option::Option<
4056 unsafe extern "C" fn(
4057 me: *mut ::std::os::raw::c_void,
4058 defaultValue: *mut ICapeString,
4059 ) -> CapeResult,
4060 >,
4061 pub getOptionList: ::std::option::Option<
4062 unsafe extern "C" fn(
4063 me: *mut ::std::os::raw::c_void,
4064 optionNames: *mut ICapeArrayString,
4065 ) -> CapeResult,
4066 >,
4067 pub getRestrictedToList: ::std::option::Option<
4068 unsafe extern "C" fn(
4069 me: *mut ::std::os::raw::c_void,
4070 restricted: *mut CapeBoolean,
4071 ) -> CapeResult,
4072 >,
4073 pub ValidateElement: ::std::option::Option<
4074 unsafe extern "C" fn(
4075 me: *mut ::std::os::raw::c_void,
4076 position: *mut ICapeArrayInteger,
4077 value: *mut ICapeString,
4078 message: *mut ICapeString,
4079 isOK: *mut CapeBoolean,
4080 ) -> CapeResult,
4081 >,
4082 pub Validate: ::std::option::Option<
4083 unsafe extern "C" fn(
4084 me: *mut ::std::os::raw::c_void,
4085 value: *mut ICapeArrayString,
4086 message: *mut ICapeString,
4087 isOK: *mut CapeBoolean,
4088 ) -> CapeResult,
4089 >,
4090}
4091#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4092const _: () = {
4093 ["Size of CAPEOPEN_1_2_ICapeArrayStringParameter_VTable"]
4094 [::std::mem::size_of::<CAPEOPEN_1_2_ICapeArrayStringParameter_VTable>() - 104usize];
4095 ["Alignment of CAPEOPEN_1_2_ICapeArrayStringParameter_VTable"]
4096 [::std::mem::align_of::<CAPEOPEN_1_2_ICapeArrayStringParameter_VTable>() - 8usize];
4097 ["Offset of field: CAPEOPEN_1_2_ICapeArrayStringParameter_VTable::base"]
4098 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeArrayStringParameter_VTable, base) - 0usize];
4099 ["Offset of field: CAPEOPEN_1_2_ICapeArrayStringParameter_VTable::getValue"]
4100 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeArrayStringParameter_VTable, getValue) - 32usize];
4101 ["Offset of field: CAPEOPEN_1_2_ICapeArrayStringParameter_VTable::putValue"]
4102 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeArrayStringParameter_VTable, putValue) - 40usize];
4103 ["Offset of field: CAPEOPEN_1_2_ICapeArrayStringParameter_VTable::GetElementValue"][::std::mem::offset_of!(
4104 CAPEOPEN_1_2_ICapeArrayStringParameter_VTable,
4105 GetElementValue
4106 )
4107 - 48usize];
4108 ["Offset of field: CAPEOPEN_1_2_ICapeArrayStringParameter_VTable::SetElementValue"][::std::mem::offset_of!(
4109 CAPEOPEN_1_2_ICapeArrayStringParameter_VTable,
4110 SetElementValue
4111 )
4112 - 56usize];
4113 ["Offset of field: CAPEOPEN_1_2_ICapeArrayStringParameter_VTable::getDefaultValue"][::std::mem::offset_of!(
4114 CAPEOPEN_1_2_ICapeArrayStringParameter_VTable,
4115 getDefaultValue
4116 )
4117 - 64usize];
4118 ["Offset of field: CAPEOPEN_1_2_ICapeArrayStringParameter_VTable::getOptionList"][::std::mem::offset_of!(
4119 CAPEOPEN_1_2_ICapeArrayStringParameter_VTable,
4120 getOptionList
4121 ) - 72usize];
4122 ["Offset of field: CAPEOPEN_1_2_ICapeArrayStringParameter_VTable::getRestrictedToList"][::std::mem::offset_of!(
4123 CAPEOPEN_1_2_ICapeArrayStringParameter_VTable,
4124 getRestrictedToList
4125 )
4126 - 80usize];
4127 ["Offset of field: CAPEOPEN_1_2_ICapeArrayStringParameter_VTable::ValidateElement"][::std::mem::offset_of!(
4128 CAPEOPEN_1_2_ICapeArrayStringParameter_VTable,
4129 ValidateElement
4130 )
4131 - 88usize];
4132 ["Offset of field: CAPEOPEN_1_2_ICapeArrayStringParameter_VTable::Validate"]
4133 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeArrayStringParameter_VTable, Validate) - 96usize];
4134};
4135#[repr(C)]
4136#[derive(Debug, Copy, Clone)]
4137pub struct _CAPEOPEN_1_2_ICapeArrayStringParameter {
4138 pub me: *mut ::std::os::raw::c_void,
4139 pub vTbl: *mut CAPEOPEN_1_2_ICapeArrayStringParameter_VTable,
4140}
4141#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4142const _: () = {
4143 ["Size of _CAPEOPEN_1_2_ICapeArrayStringParameter"]
4144 [::std::mem::size_of::<_CAPEOPEN_1_2_ICapeArrayStringParameter>() - 16usize];
4145 ["Alignment of _CAPEOPEN_1_2_ICapeArrayStringParameter"]
4146 [::std::mem::align_of::<_CAPEOPEN_1_2_ICapeArrayStringParameter>() - 8usize];
4147 ["Offset of field: _CAPEOPEN_1_2_ICapeArrayStringParameter::me"]
4148 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapeArrayStringParameter, me) - 0usize];
4149 ["Offset of field: _CAPEOPEN_1_2_ICapeArrayStringParameter::vTbl"]
4150 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapeArrayStringParameter, vTbl) - 8usize];
4151};
4152pub type CAPEOPEN_1_2_ICapeArrayStringParameter = _CAPEOPEN_1_2_ICapeArrayStringParameter;
4153#[repr(C)]
4154#[derive(Debug, Copy, Clone)]
4155pub struct CAPEOPEN_1_2_ICapeArrayBooleanParameter_VTable {
4156 pub base: ICapeInterface_VTable,
4157 pub getValue: ::std::option::Option<
4158 unsafe extern "C" fn(
4159 me: *mut ::std::os::raw::c_void,
4160 value: *mut ICapeArrayBoolean,
4161 ) -> CapeResult,
4162 >,
4163 pub putValue: ::std::option::Option<
4164 unsafe extern "C" fn(
4165 me: *mut ::std::os::raw::c_void,
4166 value: *mut ICapeArrayBoolean,
4167 ) -> CapeResult,
4168 >,
4169 pub GetElementValue: ::std::option::Option<
4170 unsafe extern "C" fn(
4171 me: *mut ::std::os::raw::c_void,
4172 position: *mut ICapeArrayInteger,
4173 value: *mut CapeBoolean,
4174 ) -> CapeResult,
4175 >,
4176 pub SetElementValue: ::std::option::Option<
4177 unsafe extern "C" fn(
4178 me: *mut ::std::os::raw::c_void,
4179 position: *mut ICapeArrayInteger,
4180 value: CapeBoolean,
4181 ) -> CapeResult,
4182 >,
4183 pub getDefaultValue: ::std::option::Option<
4184 unsafe extern "C" fn(
4185 me: *mut ::std::os::raw::c_void,
4186 defaultValue: *mut CapeBoolean,
4187 ) -> CapeResult,
4188 >,
4189 pub ValidateElement: ::std::option::Option<
4190 unsafe extern "C" fn(
4191 me: *mut ::std::os::raw::c_void,
4192 position: *mut ICapeArrayInteger,
4193 value: CapeBoolean,
4194 message: *mut ICapeString,
4195 isOK: *mut CapeBoolean,
4196 ) -> CapeResult,
4197 >,
4198 pub Validate: ::std::option::Option<
4199 unsafe extern "C" fn(
4200 me: *mut ::std::os::raw::c_void,
4201 value: *mut ICapeArrayBoolean,
4202 message: *mut ICapeString,
4203 isOK: *mut CapeBoolean,
4204 ) -> CapeResult,
4205 >,
4206}
4207#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4208const _: () = {
4209 ["Size of CAPEOPEN_1_2_ICapeArrayBooleanParameter_VTable"]
4210 [::std::mem::size_of::<CAPEOPEN_1_2_ICapeArrayBooleanParameter_VTable>() - 88usize];
4211 ["Alignment of CAPEOPEN_1_2_ICapeArrayBooleanParameter_VTable"]
4212 [::std::mem::align_of::<CAPEOPEN_1_2_ICapeArrayBooleanParameter_VTable>() - 8usize];
4213 ["Offset of field: CAPEOPEN_1_2_ICapeArrayBooleanParameter_VTable::base"]
4214 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeArrayBooleanParameter_VTable, base) - 0usize];
4215 ["Offset of field: CAPEOPEN_1_2_ICapeArrayBooleanParameter_VTable::getValue"][::std::mem::offset_of!(
4216 CAPEOPEN_1_2_ICapeArrayBooleanParameter_VTable,
4217 getValue
4218 ) - 32usize];
4219 ["Offset of field: CAPEOPEN_1_2_ICapeArrayBooleanParameter_VTable::putValue"][::std::mem::offset_of!(
4220 CAPEOPEN_1_2_ICapeArrayBooleanParameter_VTable,
4221 putValue
4222 ) - 40usize];
4223 ["Offset of field: CAPEOPEN_1_2_ICapeArrayBooleanParameter_VTable::GetElementValue"][::std::mem::offset_of!(
4224 CAPEOPEN_1_2_ICapeArrayBooleanParameter_VTable,
4225 GetElementValue
4226 )
4227 - 48usize];
4228 ["Offset of field: CAPEOPEN_1_2_ICapeArrayBooleanParameter_VTable::SetElementValue"][::std::mem::offset_of!(
4229 CAPEOPEN_1_2_ICapeArrayBooleanParameter_VTable,
4230 SetElementValue
4231 )
4232 - 56usize];
4233 ["Offset of field: CAPEOPEN_1_2_ICapeArrayBooleanParameter_VTable::getDefaultValue"][::std::mem::offset_of!(
4234 CAPEOPEN_1_2_ICapeArrayBooleanParameter_VTable,
4235 getDefaultValue
4236 )
4237 - 64usize];
4238 ["Offset of field: CAPEOPEN_1_2_ICapeArrayBooleanParameter_VTable::ValidateElement"][::std::mem::offset_of!(
4239 CAPEOPEN_1_2_ICapeArrayBooleanParameter_VTable,
4240 ValidateElement
4241 )
4242 - 72usize];
4243 ["Offset of field: CAPEOPEN_1_2_ICapeArrayBooleanParameter_VTable::Validate"][::std::mem::offset_of!(
4244 CAPEOPEN_1_2_ICapeArrayBooleanParameter_VTable,
4245 Validate
4246 ) - 80usize];
4247};
4248#[repr(C)]
4249#[derive(Debug, Copy, Clone)]
4250pub struct _CAPEOPEN_1_2_ICapeArrayBooleanParameter {
4251 pub me: *mut ::std::os::raw::c_void,
4252 pub vTbl: *mut CAPEOPEN_1_2_ICapeArrayBooleanParameter_VTable,
4253}
4254#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4255const _: () = {
4256 ["Size of _CAPEOPEN_1_2_ICapeArrayBooleanParameter"]
4257 [::std::mem::size_of::<_CAPEOPEN_1_2_ICapeArrayBooleanParameter>() - 16usize];
4258 ["Alignment of _CAPEOPEN_1_2_ICapeArrayBooleanParameter"]
4259 [::std::mem::align_of::<_CAPEOPEN_1_2_ICapeArrayBooleanParameter>() - 8usize];
4260 ["Offset of field: _CAPEOPEN_1_2_ICapeArrayBooleanParameter::me"]
4261 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapeArrayBooleanParameter, me) - 0usize];
4262 ["Offset of field: _CAPEOPEN_1_2_ICapeArrayBooleanParameter::vTbl"]
4263 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapeArrayBooleanParameter, vTbl) - 8usize];
4264};
4265pub type CAPEOPEN_1_2_ICapeArrayBooleanParameter = _CAPEOPEN_1_2_ICapeArrayBooleanParameter;
4266#[repr(C)]
4267#[derive(Debug, Copy, Clone)]
4268pub struct CAPEOPEN_1_2_ICapeParameterSpecification_VTable {
4269 pub base: ICapeInterface_VTable,
4270 pub getType: ::std::option::Option<
4271 unsafe extern "C" fn(
4272 me: *mut ::std::os::raw::c_void,
4273 parameterType: *mut CAPEOPEN_1_2_CapeParamType,
4274 ) -> CapeResult,
4275 >,
4276}
4277#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4278const _: () = {
4279 ["Size of CAPEOPEN_1_2_ICapeParameterSpecification_VTable"]
4280 [::std::mem::size_of::<CAPEOPEN_1_2_ICapeParameterSpecification_VTable>() - 40usize];
4281 ["Alignment of CAPEOPEN_1_2_ICapeParameterSpecification_VTable"]
4282 [::std::mem::align_of::<CAPEOPEN_1_2_ICapeParameterSpecification_VTable>() - 8usize];
4283 ["Offset of field: CAPEOPEN_1_2_ICapeParameterSpecification_VTable::base"]
4284 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeParameterSpecification_VTable, base) - 0usize];
4285 ["Offset of field: CAPEOPEN_1_2_ICapeParameterSpecification_VTable::getType"][::std::mem::offset_of!(
4286 CAPEOPEN_1_2_ICapeParameterSpecification_VTable,
4287 getType
4288 ) - 32usize];
4289};
4290#[repr(C)]
4291#[derive(Debug, Copy, Clone)]
4292pub struct _CAPEOPEN_1_2_ICapeParameterSpecification {
4293 pub me: *mut ::std::os::raw::c_void,
4294 pub vTbl: *mut CAPEOPEN_1_2_ICapeParameterSpecification_VTable,
4295}
4296#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4297const _: () = {
4298 ["Size of _CAPEOPEN_1_2_ICapeParameterSpecification"]
4299 [::std::mem::size_of::<_CAPEOPEN_1_2_ICapeParameterSpecification>() - 16usize];
4300 ["Alignment of _CAPEOPEN_1_2_ICapeParameterSpecification"]
4301 [::std::mem::align_of::<_CAPEOPEN_1_2_ICapeParameterSpecification>() - 8usize];
4302 ["Offset of field: _CAPEOPEN_1_2_ICapeParameterSpecification::me"]
4303 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapeParameterSpecification, me) - 0usize];
4304 ["Offset of field: _CAPEOPEN_1_2_ICapeParameterSpecification::vTbl"]
4305 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapeParameterSpecification, vTbl) - 8usize];
4306};
4307pub type CAPEOPEN_1_2_ICapeParameterSpecification = _CAPEOPEN_1_2_ICapeParameterSpecification;
4308#[repr(C)]
4309#[derive(Debug, Copy, Clone)]
4310pub struct CAPEOPEN_1_2_ICapeRealParameterSpecification_VTable {
4311 pub base: ICapeInterface_VTable,
4312 pub getDefaultValue: ::std::option::Option<
4313 unsafe extern "C" fn(
4314 me: *mut ::std::os::raw::c_void,
4315 defaultValue: *mut CapeReal,
4316 ) -> CapeResult,
4317 >,
4318 pub getLowerBound: ::std::option::Option<
4319 unsafe extern "C" fn(me: *mut ::std::os::raw::c_void, lBound: *mut CapeReal) -> CapeResult,
4320 >,
4321 pub getUpperBound: ::std::option::Option<
4322 unsafe extern "C" fn(me: *mut ::std::os::raw::c_void, uBound: *mut CapeReal) -> CapeResult,
4323 >,
4324 pub getDimensionality: ::std::option::Option<
4325 unsafe extern "C" fn(
4326 me: *mut ::std::os::raw::c_void,
4327 dimensionality: *mut ICapeArrayReal,
4328 ) -> CapeResult,
4329 >,
4330 pub Validate: ::std::option::Option<
4331 unsafe extern "C" fn(
4332 me: *mut ::std::os::raw::c_void,
4333 value: CapeReal,
4334 message: *mut ICapeString,
4335 isOK: *mut CapeBoolean,
4336 ) -> CapeResult,
4337 >,
4338}
4339#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4340const _: () = {
4341 ["Size of CAPEOPEN_1_2_ICapeRealParameterSpecification_VTable"]
4342 [::std::mem::size_of::<CAPEOPEN_1_2_ICapeRealParameterSpecification_VTable>() - 72usize];
4343 ["Alignment of CAPEOPEN_1_2_ICapeRealParameterSpecification_VTable"]
4344 [::std::mem::align_of::<CAPEOPEN_1_2_ICapeRealParameterSpecification_VTable>() - 8usize];
4345 ["Offset of field: CAPEOPEN_1_2_ICapeRealParameterSpecification_VTable::base"][::std::mem::offset_of!(
4346 CAPEOPEN_1_2_ICapeRealParameterSpecification_VTable,
4347 base
4348 ) - 0usize];
4349 ["Offset of field: CAPEOPEN_1_2_ICapeRealParameterSpecification_VTable::getDefaultValue"][::std::mem::offset_of!(
4350 CAPEOPEN_1_2_ICapeRealParameterSpecification_VTable,
4351 getDefaultValue
4352 )
4353 - 32usize];
4354 ["Offset of field: CAPEOPEN_1_2_ICapeRealParameterSpecification_VTable::getLowerBound"][::std::mem::offset_of!(
4355 CAPEOPEN_1_2_ICapeRealParameterSpecification_VTable,
4356 getLowerBound
4357 )
4358 - 40usize];
4359 ["Offset of field: CAPEOPEN_1_2_ICapeRealParameterSpecification_VTable::getUpperBound"][::std::mem::offset_of!(
4360 CAPEOPEN_1_2_ICapeRealParameterSpecification_VTable,
4361 getUpperBound
4362 )
4363 - 48usize];
4364 ["Offset of field: CAPEOPEN_1_2_ICapeRealParameterSpecification_VTable::getDimensionality"][::std::mem::offset_of!(
4365 CAPEOPEN_1_2_ICapeRealParameterSpecification_VTable,
4366 getDimensionality
4367 )
4368 - 56usize];
4369 ["Offset of field: CAPEOPEN_1_2_ICapeRealParameterSpecification_VTable::Validate"][::std::mem::offset_of!(
4370 CAPEOPEN_1_2_ICapeRealParameterSpecification_VTable,
4371 Validate
4372 ) - 64usize];
4373};
4374#[repr(C)]
4375#[derive(Debug, Copy, Clone)]
4376pub struct _CAPEOPEN_1_2_ICapeRealParameterSpecification {
4377 pub me: *mut ::std::os::raw::c_void,
4378 pub vTbl: *mut CAPEOPEN_1_2_ICapeRealParameterSpecification_VTable,
4379}
4380#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4381const _: () = {
4382 ["Size of _CAPEOPEN_1_2_ICapeRealParameterSpecification"]
4383 [::std::mem::size_of::<_CAPEOPEN_1_2_ICapeRealParameterSpecification>() - 16usize];
4384 ["Alignment of _CAPEOPEN_1_2_ICapeRealParameterSpecification"]
4385 [::std::mem::align_of::<_CAPEOPEN_1_2_ICapeRealParameterSpecification>() - 8usize];
4386 ["Offset of field: _CAPEOPEN_1_2_ICapeRealParameterSpecification::me"]
4387 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapeRealParameterSpecification, me) - 0usize];
4388 ["Offset of field: _CAPEOPEN_1_2_ICapeRealParameterSpecification::vTbl"]
4389 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapeRealParameterSpecification, vTbl) - 8usize];
4390};
4391pub type CAPEOPEN_1_2_ICapeRealParameterSpecification =
4392 _CAPEOPEN_1_2_ICapeRealParameterSpecification;
4393#[repr(C)]
4394#[derive(Debug, Copy, Clone)]
4395pub struct CAPEOPEN_1_2_ICapeIntegerParameterSpecification_VTable {
4396 pub base: ICapeInterface_VTable,
4397 pub getDefaultValue: ::std::option::Option<
4398 unsafe extern "C" fn(
4399 me: *mut ::std::os::raw::c_void,
4400 defaultValue: *mut CapeInteger,
4401 ) -> CapeResult,
4402 >,
4403 pub getLowerBound: ::std::option::Option<
4404 unsafe extern "C" fn(
4405 me: *mut ::std::os::raw::c_void,
4406 lBound: *mut CapeInteger,
4407 ) -> CapeResult,
4408 >,
4409 pub getUpperBound: ::std::option::Option<
4410 unsafe extern "C" fn(
4411 me: *mut ::std::os::raw::c_void,
4412 uBound: *mut CapeInteger,
4413 ) -> CapeResult,
4414 >,
4415 pub Validate: ::std::option::Option<
4416 unsafe extern "C" fn(
4417 me: *mut ::std::os::raw::c_void,
4418 value: CapeInteger,
4419 message: *mut ICapeString,
4420 isOK: *mut CapeBoolean,
4421 ) -> CapeResult,
4422 >,
4423}
4424#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4425const _: () = {
4426 ["Size of CAPEOPEN_1_2_ICapeIntegerParameterSpecification_VTable"]
4427 [::std::mem::size_of::<CAPEOPEN_1_2_ICapeIntegerParameterSpecification_VTable>() - 64usize];
4428 ["Alignment of CAPEOPEN_1_2_ICapeIntegerParameterSpecification_VTable"]
4429 [::std::mem::align_of::<CAPEOPEN_1_2_ICapeIntegerParameterSpecification_VTable>() - 8usize];
4430 ["Offset of field: CAPEOPEN_1_2_ICapeIntegerParameterSpecification_VTable::base"][::std::mem::offset_of!(
4431 CAPEOPEN_1_2_ICapeIntegerParameterSpecification_VTable,
4432 base
4433 ) - 0usize];
4434 ["Offset of field: CAPEOPEN_1_2_ICapeIntegerParameterSpecification_VTable::getDefaultValue"][::std::mem::offset_of!(
4435 CAPEOPEN_1_2_ICapeIntegerParameterSpecification_VTable,
4436 getDefaultValue
4437 )
4438 - 32usize];
4439 ["Offset of field: CAPEOPEN_1_2_ICapeIntegerParameterSpecification_VTable::getLowerBound"][::std::mem::offset_of!(
4440 CAPEOPEN_1_2_ICapeIntegerParameterSpecification_VTable,
4441 getLowerBound
4442 )
4443 - 40usize];
4444 ["Offset of field: CAPEOPEN_1_2_ICapeIntegerParameterSpecification_VTable::getUpperBound"][::std::mem::offset_of!(
4445 CAPEOPEN_1_2_ICapeIntegerParameterSpecification_VTable,
4446 getUpperBound
4447 )
4448 - 48usize];
4449 ["Offset of field: CAPEOPEN_1_2_ICapeIntegerParameterSpecification_VTable::Validate"][::std::mem::offset_of!(
4450 CAPEOPEN_1_2_ICapeIntegerParameterSpecification_VTable,
4451 Validate
4452 )
4453 - 56usize];
4454};
4455#[repr(C)]
4456#[derive(Debug, Copy, Clone)]
4457pub struct _CAPEOPEN_1_2_ICapeIntegerParameterSpecification {
4458 pub me: *mut ::std::os::raw::c_void,
4459 pub vTbl: *mut CAPEOPEN_1_2_ICapeIntegerParameterSpecification_VTable,
4460}
4461#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4462const _: () = {
4463 ["Size of _CAPEOPEN_1_2_ICapeIntegerParameterSpecification"]
4464 [::std::mem::size_of::<_CAPEOPEN_1_2_ICapeIntegerParameterSpecification>() - 16usize];
4465 ["Alignment of _CAPEOPEN_1_2_ICapeIntegerParameterSpecification"]
4466 [::std::mem::align_of::<_CAPEOPEN_1_2_ICapeIntegerParameterSpecification>() - 8usize];
4467 ["Offset of field: _CAPEOPEN_1_2_ICapeIntegerParameterSpecification::me"]
4468 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapeIntegerParameterSpecification, me) - 0usize];
4469 ["Offset of field: _CAPEOPEN_1_2_ICapeIntegerParameterSpecification::vTbl"]
4470 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapeIntegerParameterSpecification, vTbl) - 8usize];
4471};
4472pub type CAPEOPEN_1_2_ICapeIntegerParameterSpecification =
4473 _CAPEOPEN_1_2_ICapeIntegerParameterSpecification;
4474#[repr(C)]
4475#[derive(Debug, Copy, Clone)]
4476pub struct CAPEOPEN_1_2_ICapeStringParameterSpecification_VTable {
4477 pub base: ICapeInterface_VTable,
4478 pub getDefaultValue: ::std::option::Option<
4479 unsafe extern "C" fn(
4480 me: *mut ::std::os::raw::c_void,
4481 defaultValue: *mut ICapeString,
4482 ) -> CapeResult,
4483 >,
4484 pub getOptionList: ::std::option::Option<
4485 unsafe extern "C" fn(
4486 me: *mut ::std::os::raw::c_void,
4487 optionNames: *mut ICapeArrayString,
4488 ) -> CapeResult,
4489 >,
4490 pub getRestrictedToList: ::std::option::Option<
4491 unsafe extern "C" fn(
4492 me: *mut ::std::os::raw::c_void,
4493 restricted: *mut CapeBoolean,
4494 ) -> CapeResult,
4495 >,
4496 pub Validate: ::std::option::Option<
4497 unsafe extern "C" fn(
4498 me: *mut ::std::os::raw::c_void,
4499 value: *mut ICapeString,
4500 message: *mut ICapeString,
4501 isOK: *mut CapeBoolean,
4502 ) -> CapeResult,
4503 >,
4504}
4505#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4506const _: () = {
4507 ["Size of CAPEOPEN_1_2_ICapeStringParameterSpecification_VTable"]
4508 [::std::mem::size_of::<CAPEOPEN_1_2_ICapeStringParameterSpecification_VTable>() - 64usize];
4509 ["Alignment of CAPEOPEN_1_2_ICapeStringParameterSpecification_VTable"]
4510 [::std::mem::align_of::<CAPEOPEN_1_2_ICapeStringParameterSpecification_VTable>() - 8usize];
4511 ["Offset of field: CAPEOPEN_1_2_ICapeStringParameterSpecification_VTable::base"][::std::mem::offset_of!(
4512 CAPEOPEN_1_2_ICapeStringParameterSpecification_VTable,
4513 base
4514 ) - 0usize];
4515 ["Offset of field: CAPEOPEN_1_2_ICapeStringParameterSpecification_VTable::getDefaultValue"][::std::mem::offset_of!(
4516 CAPEOPEN_1_2_ICapeStringParameterSpecification_VTable,
4517 getDefaultValue
4518 )
4519 - 32usize];
4520 ["Offset of field: CAPEOPEN_1_2_ICapeStringParameterSpecification_VTable::getOptionList"][::std::mem::offset_of!(
4521 CAPEOPEN_1_2_ICapeStringParameterSpecification_VTable,
4522 getOptionList
4523 )
4524 - 40usize];
4525 ["Offset of field: CAPEOPEN_1_2_ICapeStringParameterSpecification_VTable::getRestrictedToList"] [:: std :: mem :: offset_of ! (CAPEOPEN_1_2_ICapeStringParameterSpecification_VTable , getRestrictedToList) - 48usize] ;
4526 ["Offset of field: CAPEOPEN_1_2_ICapeStringParameterSpecification_VTable::Validate"][::std::mem::offset_of!(
4527 CAPEOPEN_1_2_ICapeStringParameterSpecification_VTable,
4528 Validate
4529 )
4530 - 56usize];
4531};
4532#[repr(C)]
4533#[derive(Debug, Copy, Clone)]
4534pub struct _CAPEOPEN_1_2_ICapeStringParameterSpecification {
4535 pub me: *mut ::std::os::raw::c_void,
4536 pub vTbl: *mut CAPEOPEN_1_2_ICapeStringParameterSpecification_VTable,
4537}
4538#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4539const _: () = {
4540 ["Size of _CAPEOPEN_1_2_ICapeStringParameterSpecification"]
4541 [::std::mem::size_of::<_CAPEOPEN_1_2_ICapeStringParameterSpecification>() - 16usize];
4542 ["Alignment of _CAPEOPEN_1_2_ICapeStringParameterSpecification"]
4543 [::std::mem::align_of::<_CAPEOPEN_1_2_ICapeStringParameterSpecification>() - 8usize];
4544 ["Offset of field: _CAPEOPEN_1_2_ICapeStringParameterSpecification::me"]
4545 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapeStringParameterSpecification, me) - 0usize];
4546 ["Offset of field: _CAPEOPEN_1_2_ICapeStringParameterSpecification::vTbl"]
4547 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapeStringParameterSpecification, vTbl) - 8usize];
4548};
4549pub type CAPEOPEN_1_2_ICapeStringParameterSpecification =
4550 _CAPEOPEN_1_2_ICapeStringParameterSpecification;
4551#[repr(C)]
4552#[derive(Debug, Copy, Clone)]
4553pub struct CAPEOPEN_1_2_ICapeBooleanParameterSpecification_VTable {
4554 pub base: ICapeInterface_VTable,
4555 pub getDefaultValue: ::std::option::Option<
4556 unsafe extern "C" fn(
4557 me: *mut ::std::os::raw::c_void,
4558 defaultValue: *mut CapeBoolean,
4559 ) -> CapeResult,
4560 >,
4561 pub Validate: ::std::option::Option<
4562 unsafe extern "C" fn(
4563 me: *mut ::std::os::raw::c_void,
4564 value: CapeBoolean,
4565 message: *mut ICapeString,
4566 isOK: *mut CapeBoolean,
4567 ) -> CapeResult,
4568 >,
4569}
4570#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4571const _: () = {
4572 ["Size of CAPEOPEN_1_2_ICapeBooleanParameterSpecification_VTable"]
4573 [::std::mem::size_of::<CAPEOPEN_1_2_ICapeBooleanParameterSpecification_VTable>() - 48usize];
4574 ["Alignment of CAPEOPEN_1_2_ICapeBooleanParameterSpecification_VTable"]
4575 [::std::mem::align_of::<CAPEOPEN_1_2_ICapeBooleanParameterSpecification_VTable>() - 8usize];
4576 ["Offset of field: CAPEOPEN_1_2_ICapeBooleanParameterSpecification_VTable::base"][::std::mem::offset_of!(
4577 CAPEOPEN_1_2_ICapeBooleanParameterSpecification_VTable,
4578 base
4579 ) - 0usize];
4580 ["Offset of field: CAPEOPEN_1_2_ICapeBooleanParameterSpecification_VTable::getDefaultValue"][::std::mem::offset_of!(
4581 CAPEOPEN_1_2_ICapeBooleanParameterSpecification_VTable,
4582 getDefaultValue
4583 )
4584 - 32usize];
4585 ["Offset of field: CAPEOPEN_1_2_ICapeBooleanParameterSpecification_VTable::Validate"][::std::mem::offset_of!(
4586 CAPEOPEN_1_2_ICapeBooleanParameterSpecification_VTable,
4587 Validate
4588 )
4589 - 40usize];
4590};
4591#[repr(C)]
4592#[derive(Debug, Copy, Clone)]
4593pub struct _CAPEOPEN_1_2_ICapeBooleanParameterSpecification {
4594 pub me: *mut ::std::os::raw::c_void,
4595 pub vTbl: *mut CAPEOPEN_1_2_ICapeBooleanParameterSpecification_VTable,
4596}
4597#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4598const _: () = {
4599 ["Size of _CAPEOPEN_1_2_ICapeBooleanParameterSpecification"]
4600 [::std::mem::size_of::<_CAPEOPEN_1_2_ICapeBooleanParameterSpecification>() - 16usize];
4601 ["Alignment of _CAPEOPEN_1_2_ICapeBooleanParameterSpecification"]
4602 [::std::mem::align_of::<_CAPEOPEN_1_2_ICapeBooleanParameterSpecification>() - 8usize];
4603 ["Offset of field: _CAPEOPEN_1_2_ICapeBooleanParameterSpecification::me"]
4604 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapeBooleanParameterSpecification, me) - 0usize];
4605 ["Offset of field: _CAPEOPEN_1_2_ICapeBooleanParameterSpecification::vTbl"]
4606 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapeBooleanParameterSpecification, vTbl) - 8usize];
4607};
4608pub type CAPEOPEN_1_2_ICapeBooleanParameterSpecification =
4609 _CAPEOPEN_1_2_ICapeBooleanParameterSpecification;
4610#[repr(C)]
4611#[derive(Debug, Copy, Clone)]
4612pub struct CAPEOPEN_1_2_ICapeArrayParameterSpecification_VTable {
4613 pub base: ICapeInterface_VTable,
4614 pub getNumDimensions: ::std::option::Option<
4615 unsafe extern "C" fn(
4616 me: *mut ::std::os::raw::c_void,
4617 numDimensions: *mut CapeInteger,
4618 ) -> CapeResult,
4619 >,
4620 pub getSize: ::std::option::Option<
4621 unsafe extern "C" fn(
4622 me: *mut ::std::os::raw::c_void,
4623 size: *mut ICapeArrayInteger,
4624 ) -> CapeResult,
4625 >,
4626}
4627#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4628const _: () = {
4629 ["Size of CAPEOPEN_1_2_ICapeArrayParameterSpecification_VTable"]
4630 [::std::mem::size_of::<CAPEOPEN_1_2_ICapeArrayParameterSpecification_VTable>() - 48usize];
4631 ["Alignment of CAPEOPEN_1_2_ICapeArrayParameterSpecification_VTable"]
4632 [::std::mem::align_of::<CAPEOPEN_1_2_ICapeArrayParameterSpecification_VTable>() - 8usize];
4633 ["Offset of field: CAPEOPEN_1_2_ICapeArrayParameterSpecification_VTable::base"][::std::mem::offset_of!(
4634 CAPEOPEN_1_2_ICapeArrayParameterSpecification_VTable,
4635 base
4636 ) - 0usize];
4637 ["Offset of field: CAPEOPEN_1_2_ICapeArrayParameterSpecification_VTable::getNumDimensions"][::std::mem::offset_of!(
4638 CAPEOPEN_1_2_ICapeArrayParameterSpecification_VTable,
4639 getNumDimensions
4640 )
4641 - 32usize];
4642 ["Offset of field: CAPEOPEN_1_2_ICapeArrayParameterSpecification_VTable::getSize"][::std::mem::offset_of!(
4643 CAPEOPEN_1_2_ICapeArrayParameterSpecification_VTable,
4644 getSize
4645 ) - 40usize];
4646};
4647#[repr(C)]
4648#[derive(Debug, Copy, Clone)]
4649pub struct _CAPEOPEN_1_2_ICapeArrayParameterSpecification {
4650 pub me: *mut ::std::os::raw::c_void,
4651 pub vTbl: *mut CAPEOPEN_1_2_ICapeArrayParameterSpecification_VTable,
4652}
4653#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4654const _: () = {
4655 ["Size of _CAPEOPEN_1_2_ICapeArrayParameterSpecification"]
4656 [::std::mem::size_of::<_CAPEOPEN_1_2_ICapeArrayParameterSpecification>() - 16usize];
4657 ["Alignment of _CAPEOPEN_1_2_ICapeArrayParameterSpecification"]
4658 [::std::mem::align_of::<_CAPEOPEN_1_2_ICapeArrayParameterSpecification>() - 8usize];
4659 ["Offset of field: _CAPEOPEN_1_2_ICapeArrayParameterSpecification::me"]
4660 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapeArrayParameterSpecification, me) - 0usize];
4661 ["Offset of field: _CAPEOPEN_1_2_ICapeArrayParameterSpecification::vTbl"]
4662 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapeArrayParameterSpecification, vTbl) - 8usize];
4663};
4664pub type CAPEOPEN_1_2_ICapeArrayParameterSpecification =
4665 _CAPEOPEN_1_2_ICapeArrayParameterSpecification;
4666#[repr(C)]
4667#[derive(Debug, Copy, Clone)]
4668pub struct CAPEOPEN_1_2_ICapeArrayRealParameterSpecification_VTable {
4669 pub base: ICapeInterface_VTable,
4670 pub getDefaultValue: ::std::option::Option<
4671 unsafe extern "C" fn(
4672 me: *mut ::std::os::raw::c_void,
4673 defaultValue: *mut CapeReal,
4674 ) -> CapeResult,
4675 >,
4676 pub getLowerBound: ::std::option::Option<
4677 unsafe extern "C" fn(me: *mut ::std::os::raw::c_void, lBound: *mut CapeReal) -> CapeResult,
4678 >,
4679 pub getUpperBound: ::std::option::Option<
4680 unsafe extern "C" fn(me: *mut ::std::os::raw::c_void, uBound: *mut CapeReal) -> CapeResult,
4681 >,
4682 pub getDimensionality: ::std::option::Option<
4683 unsafe extern "C" fn(
4684 me: *mut ::std::os::raw::c_void,
4685 dimensionality: *mut ICapeArrayReal,
4686 ) -> CapeResult,
4687 >,
4688 pub ValidateElement: ::std::option::Option<
4689 unsafe extern "C" fn(
4690 me: *mut ::std::os::raw::c_void,
4691 position: *mut ICapeArrayInteger,
4692 value: CapeReal,
4693 message: *mut ICapeString,
4694 isOK: *mut CapeBoolean,
4695 ) -> CapeResult,
4696 >,
4697 pub Validate: ::std::option::Option<
4698 unsafe extern "C" fn(
4699 me: *mut ::std::os::raw::c_void,
4700 value: *mut ICapeArrayReal,
4701 message: *mut ICapeString,
4702 isOK: *mut CapeBoolean,
4703 ) -> CapeResult,
4704 >,
4705}
4706#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4707const _: () = {
4708 ["Size of CAPEOPEN_1_2_ICapeArrayRealParameterSpecification_VTable"][::std::mem::size_of::<
4709 CAPEOPEN_1_2_ICapeArrayRealParameterSpecification_VTable,
4710 >() - 80usize];
4711 ["Alignment of CAPEOPEN_1_2_ICapeArrayRealParameterSpecification_VTable"][::std::mem::align_of::<
4712 CAPEOPEN_1_2_ICapeArrayRealParameterSpecification_VTable,
4713 >() - 8usize];
4714 ["Offset of field: CAPEOPEN_1_2_ICapeArrayRealParameterSpecification_VTable::base"][::std::mem::offset_of!(
4715 CAPEOPEN_1_2_ICapeArrayRealParameterSpecification_VTable,
4716 base
4717 ) - 0usize];
4718 ["Offset of field: CAPEOPEN_1_2_ICapeArrayRealParameterSpecification_VTable::getDefaultValue"] [:: std :: mem :: offset_of ! (CAPEOPEN_1_2_ICapeArrayRealParameterSpecification_VTable , getDefaultValue) - 32usize] ;
4719 ["Offset of field: CAPEOPEN_1_2_ICapeArrayRealParameterSpecification_VTable::getLowerBound"][::std::mem::offset_of!(
4720 CAPEOPEN_1_2_ICapeArrayRealParameterSpecification_VTable,
4721 getLowerBound
4722 )
4723 - 40usize];
4724 ["Offset of field: CAPEOPEN_1_2_ICapeArrayRealParameterSpecification_VTable::getUpperBound"][::std::mem::offset_of!(
4725 CAPEOPEN_1_2_ICapeArrayRealParameterSpecification_VTable,
4726 getUpperBound
4727 )
4728 - 48usize];
4729 ["Offset of field: CAPEOPEN_1_2_ICapeArrayRealParameterSpecification_VTable::getDimensionality"] [:: std :: mem :: offset_of ! (CAPEOPEN_1_2_ICapeArrayRealParameterSpecification_VTable , getDimensionality) - 56usize] ;
4730 ["Offset of field: CAPEOPEN_1_2_ICapeArrayRealParameterSpecification_VTable::ValidateElement"] [:: std :: mem :: offset_of ! (CAPEOPEN_1_2_ICapeArrayRealParameterSpecification_VTable , ValidateElement) - 64usize] ;
4731 ["Offset of field: CAPEOPEN_1_2_ICapeArrayRealParameterSpecification_VTable::Validate"][::std::mem::offset_of!(
4732 CAPEOPEN_1_2_ICapeArrayRealParameterSpecification_VTable,
4733 Validate
4734 )
4735 - 72usize];
4736};
4737#[repr(C)]
4738#[derive(Debug, Copy, Clone)]
4739pub struct _CAPEOPEN_1_2_ICapeArrayRealParameterSpecification {
4740 pub me: *mut ::std::os::raw::c_void,
4741 pub vTbl: *mut CAPEOPEN_1_2_ICapeArrayRealParameterSpecification_VTable,
4742}
4743#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4744const _: () = {
4745 ["Size of _CAPEOPEN_1_2_ICapeArrayRealParameterSpecification"]
4746 [::std::mem::size_of::<_CAPEOPEN_1_2_ICapeArrayRealParameterSpecification>() - 16usize];
4747 ["Alignment of _CAPEOPEN_1_2_ICapeArrayRealParameterSpecification"]
4748 [::std::mem::align_of::<_CAPEOPEN_1_2_ICapeArrayRealParameterSpecification>() - 8usize];
4749 ["Offset of field: _CAPEOPEN_1_2_ICapeArrayRealParameterSpecification::me"]
4750 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapeArrayRealParameterSpecification, me) - 0usize];
4751 ["Offset of field: _CAPEOPEN_1_2_ICapeArrayRealParameterSpecification::vTbl"]
4752 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapeArrayRealParameterSpecification, vTbl) - 8usize];
4753};
4754pub type CAPEOPEN_1_2_ICapeArrayRealParameterSpecification =
4755 _CAPEOPEN_1_2_ICapeArrayRealParameterSpecification;
4756#[repr(C)]
4757#[derive(Debug, Copy, Clone)]
4758pub struct CAPEOPEN_1_2_ICapeArrayIntegerParameterSpecification_VTable {
4759 pub base: ICapeInterface_VTable,
4760 pub getDefaultValue: ::std::option::Option<
4761 unsafe extern "C" fn(
4762 me: *mut ::std::os::raw::c_void,
4763 defaultValue: *mut CapeInteger,
4764 ) -> CapeResult,
4765 >,
4766 pub getLowerBound: ::std::option::Option<
4767 unsafe extern "C" fn(
4768 me: *mut ::std::os::raw::c_void,
4769 lBound: *mut CapeInteger,
4770 ) -> CapeResult,
4771 >,
4772 pub getUpperBound: ::std::option::Option<
4773 unsafe extern "C" fn(
4774 me: *mut ::std::os::raw::c_void,
4775 uBound: *mut CapeInteger,
4776 ) -> CapeResult,
4777 >,
4778 pub ValidateElement: ::std::option::Option<
4779 unsafe extern "C" fn(
4780 me: *mut ::std::os::raw::c_void,
4781 position: *mut ICapeArrayInteger,
4782 value: CapeInteger,
4783 message: *mut ICapeString,
4784 isOK: *mut CapeBoolean,
4785 ) -> CapeResult,
4786 >,
4787 pub Validate: ::std::option::Option<
4788 unsafe extern "C" fn(
4789 me: *mut ::std::os::raw::c_void,
4790 value: *mut ICapeArrayInteger,
4791 message: *mut ICapeString,
4792 isOK: *mut CapeBoolean,
4793 ) -> CapeResult,
4794 >,
4795}
4796#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4797const _: () = {
4798 ["Size of CAPEOPEN_1_2_ICapeArrayIntegerParameterSpecification_VTable"][::std::mem::size_of::<
4799 CAPEOPEN_1_2_ICapeArrayIntegerParameterSpecification_VTable,
4800 >() - 72usize];
4801 ["Alignment of CAPEOPEN_1_2_ICapeArrayIntegerParameterSpecification_VTable"]
4802 [::std::mem::align_of::<CAPEOPEN_1_2_ICapeArrayIntegerParameterSpecification_VTable>()
4803 - 8usize];
4804 ["Offset of field: CAPEOPEN_1_2_ICapeArrayIntegerParameterSpecification_VTable::base"][::std::mem::offset_of!(
4805 CAPEOPEN_1_2_ICapeArrayIntegerParameterSpecification_VTable,
4806 base
4807 )
4808 - 0usize];
4809 ["Offset of field: CAPEOPEN_1_2_ICapeArrayIntegerParameterSpecification_VTable::getDefaultValue"] [:: std :: mem :: offset_of ! (CAPEOPEN_1_2_ICapeArrayIntegerParameterSpecification_VTable , getDefaultValue) - 32usize] ;
4810 ["Offset of field: CAPEOPEN_1_2_ICapeArrayIntegerParameterSpecification_VTable::getLowerBound"] [:: std :: mem :: offset_of ! (CAPEOPEN_1_2_ICapeArrayIntegerParameterSpecification_VTable , getLowerBound) - 40usize] ;
4811 ["Offset of field: CAPEOPEN_1_2_ICapeArrayIntegerParameterSpecification_VTable::getUpperBound"] [:: std :: mem :: offset_of ! (CAPEOPEN_1_2_ICapeArrayIntegerParameterSpecification_VTable , getUpperBound) - 48usize] ;
4812 ["Offset of field: CAPEOPEN_1_2_ICapeArrayIntegerParameterSpecification_VTable::ValidateElement"] [:: std :: mem :: offset_of ! (CAPEOPEN_1_2_ICapeArrayIntegerParameterSpecification_VTable , ValidateElement) - 56usize] ;
4813 ["Offset of field: CAPEOPEN_1_2_ICapeArrayIntegerParameterSpecification_VTable::Validate"][::std::mem::offset_of!(
4814 CAPEOPEN_1_2_ICapeArrayIntegerParameterSpecification_VTable,
4815 Validate
4816 )
4817 - 64usize];
4818};
4819#[repr(C)]
4820#[derive(Debug, Copy, Clone)]
4821pub struct _CAPEOPEN_1_2_ICapeArrayIntegerParameterSpecification {
4822 pub me: *mut ::std::os::raw::c_void,
4823 pub vTbl: *mut CAPEOPEN_1_2_ICapeArrayIntegerParameterSpecification_VTable,
4824}
4825#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4826const _: () = {
4827 ["Size of _CAPEOPEN_1_2_ICapeArrayIntegerParameterSpecification"]
4828 [::std::mem::size_of::<_CAPEOPEN_1_2_ICapeArrayIntegerParameterSpecification>() - 16usize];
4829 ["Alignment of _CAPEOPEN_1_2_ICapeArrayIntegerParameterSpecification"]
4830 [::std::mem::align_of::<_CAPEOPEN_1_2_ICapeArrayIntegerParameterSpecification>() - 8usize];
4831 ["Offset of field: _CAPEOPEN_1_2_ICapeArrayIntegerParameterSpecification::me"][::std::mem::offset_of!(
4832 _CAPEOPEN_1_2_ICapeArrayIntegerParameterSpecification,
4833 me
4834 ) - 0usize];
4835 ["Offset of field: _CAPEOPEN_1_2_ICapeArrayIntegerParameterSpecification::vTbl"][::std::mem::offset_of!(
4836 _CAPEOPEN_1_2_ICapeArrayIntegerParameterSpecification,
4837 vTbl
4838 ) - 8usize];
4839};
4840pub type CAPEOPEN_1_2_ICapeArrayIntegerParameterSpecification =
4841 _CAPEOPEN_1_2_ICapeArrayIntegerParameterSpecification;
4842#[repr(C)]
4843#[derive(Debug, Copy, Clone)]
4844pub struct CAPEOPEN_1_2_ICapeArrayStringParameterSpecification_VTable {
4845 pub base: ICapeInterface_VTable,
4846 pub getDefaultValue: ::std::option::Option<
4847 unsafe extern "C" fn(
4848 me: *mut ::std::os::raw::c_void,
4849 defaultValue: *mut ICapeString,
4850 ) -> CapeResult,
4851 >,
4852 pub getOptionList: ::std::option::Option<
4853 unsafe extern "C" fn(
4854 me: *mut ::std::os::raw::c_void,
4855 optionNames: *mut ICapeArrayString,
4856 ) -> CapeResult,
4857 >,
4858 pub getRestrictedToList: ::std::option::Option<
4859 unsafe extern "C" fn(
4860 me: *mut ::std::os::raw::c_void,
4861 restricted: *mut CapeBoolean,
4862 ) -> CapeResult,
4863 >,
4864 pub ValidateElement: ::std::option::Option<
4865 unsafe extern "C" fn(
4866 me: *mut ::std::os::raw::c_void,
4867 position: *mut ICapeArrayInteger,
4868 value: *mut ICapeString,
4869 message: *mut ICapeString,
4870 isOK: *mut CapeBoolean,
4871 ) -> CapeResult,
4872 >,
4873 pub Validate: ::std::option::Option<
4874 unsafe extern "C" fn(
4875 me: *mut ::std::os::raw::c_void,
4876 value: *mut ICapeArrayString,
4877 message: *mut ICapeString,
4878 isOK: *mut CapeBoolean,
4879 ) -> CapeResult,
4880 >,
4881}
4882#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4883const _: () = {
4884 ["Size of CAPEOPEN_1_2_ICapeArrayStringParameterSpecification_VTable"][::std::mem::size_of::<
4885 CAPEOPEN_1_2_ICapeArrayStringParameterSpecification_VTable,
4886 >() - 72usize];
4887 ["Alignment of CAPEOPEN_1_2_ICapeArrayStringParameterSpecification_VTable"][::std::mem::align_of::<
4888 CAPEOPEN_1_2_ICapeArrayStringParameterSpecification_VTable,
4889 >() - 8usize];
4890 ["Offset of field: CAPEOPEN_1_2_ICapeArrayStringParameterSpecification_VTable::base"][::std::mem::offset_of!(
4891 CAPEOPEN_1_2_ICapeArrayStringParameterSpecification_VTable,
4892 base
4893 )
4894 - 0usize];
4895 ["Offset of field: CAPEOPEN_1_2_ICapeArrayStringParameterSpecification_VTable::getDefaultValue"] [:: std :: mem :: offset_of ! (CAPEOPEN_1_2_ICapeArrayStringParameterSpecification_VTable , getDefaultValue) - 32usize] ;
4896 ["Offset of field: CAPEOPEN_1_2_ICapeArrayStringParameterSpecification_VTable::getOptionList"] [:: std :: mem :: offset_of ! (CAPEOPEN_1_2_ICapeArrayStringParameterSpecification_VTable , getOptionList) - 40usize] ;
4897 ["Offset of field: CAPEOPEN_1_2_ICapeArrayStringParameterSpecification_VTable::getRestrictedToList"] [:: std :: mem :: offset_of ! (CAPEOPEN_1_2_ICapeArrayStringParameterSpecification_VTable , getRestrictedToList) - 48usize] ;
4898 ["Offset of field: CAPEOPEN_1_2_ICapeArrayStringParameterSpecification_VTable::ValidateElement"] [:: std :: mem :: offset_of ! (CAPEOPEN_1_2_ICapeArrayStringParameterSpecification_VTable , ValidateElement) - 56usize] ;
4899 ["Offset of field: CAPEOPEN_1_2_ICapeArrayStringParameterSpecification_VTable::Validate"][::std::mem::offset_of!(
4900 CAPEOPEN_1_2_ICapeArrayStringParameterSpecification_VTable,
4901 Validate
4902 )
4903 - 64usize];
4904};
4905#[repr(C)]
4906#[derive(Debug, Copy, Clone)]
4907pub struct _CAPEOPEN_1_2_ICapeArrayStringParameterSpecification {
4908 pub me: *mut ::std::os::raw::c_void,
4909 pub vTbl: *mut CAPEOPEN_1_2_ICapeArrayStringParameterSpecification_VTable,
4910}
4911#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4912const _: () = {
4913 ["Size of _CAPEOPEN_1_2_ICapeArrayStringParameterSpecification"]
4914 [::std::mem::size_of::<_CAPEOPEN_1_2_ICapeArrayStringParameterSpecification>() - 16usize];
4915 ["Alignment of _CAPEOPEN_1_2_ICapeArrayStringParameterSpecification"]
4916 [::std::mem::align_of::<_CAPEOPEN_1_2_ICapeArrayStringParameterSpecification>() - 8usize];
4917 ["Offset of field: _CAPEOPEN_1_2_ICapeArrayStringParameterSpecification::me"]
4918 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapeArrayStringParameterSpecification, me) - 0usize];
4919 ["Offset of field: _CAPEOPEN_1_2_ICapeArrayStringParameterSpecification::vTbl"][::std::mem::offset_of!(
4920 _CAPEOPEN_1_2_ICapeArrayStringParameterSpecification,
4921 vTbl
4922 ) - 8usize];
4923};
4924pub type CAPEOPEN_1_2_ICapeArrayStringParameterSpecification =
4925 _CAPEOPEN_1_2_ICapeArrayStringParameterSpecification;
4926#[repr(C)]
4927#[derive(Debug, Copy, Clone)]
4928pub struct CAPEOPEN_1_2_ICapeArrayBooleanParameterSpecification_VTable {
4929 pub base: ICapeInterface_VTable,
4930 pub getDefaultValue: ::std::option::Option<
4931 unsafe extern "C" fn(
4932 me: *mut ::std::os::raw::c_void,
4933 defaultValue: *mut CapeBoolean,
4934 ) -> CapeResult,
4935 >,
4936 pub ValidateElement: ::std::option::Option<
4937 unsafe extern "C" fn(
4938 me: *mut ::std::os::raw::c_void,
4939 position: *mut ICapeArrayInteger,
4940 value: CapeBoolean,
4941 message: *mut ICapeString,
4942 isOK: *mut CapeBoolean,
4943 ) -> CapeResult,
4944 >,
4945 pub Validate: ::std::option::Option<
4946 unsafe extern "C" fn(
4947 me: *mut ::std::os::raw::c_void,
4948 value: *mut ICapeArrayBoolean,
4949 message: *mut ICapeString,
4950 isOK: *mut CapeBoolean,
4951 ) -> CapeResult,
4952 >,
4953}
4954#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4955const _: () = {
4956 ["Size of CAPEOPEN_1_2_ICapeArrayBooleanParameterSpecification_VTable"][::std::mem::size_of::<
4957 CAPEOPEN_1_2_ICapeArrayBooleanParameterSpecification_VTable,
4958 >() - 56usize];
4959 ["Alignment of CAPEOPEN_1_2_ICapeArrayBooleanParameterSpecification_VTable"]
4960 [::std::mem::align_of::<CAPEOPEN_1_2_ICapeArrayBooleanParameterSpecification_VTable>()
4961 - 8usize];
4962 ["Offset of field: CAPEOPEN_1_2_ICapeArrayBooleanParameterSpecification_VTable::base"][::std::mem::offset_of!(
4963 CAPEOPEN_1_2_ICapeArrayBooleanParameterSpecification_VTable,
4964 base
4965 )
4966 - 0usize];
4967 ["Offset of field: CAPEOPEN_1_2_ICapeArrayBooleanParameterSpecification_VTable::getDefaultValue"] [:: std :: mem :: offset_of ! (CAPEOPEN_1_2_ICapeArrayBooleanParameterSpecification_VTable , getDefaultValue) - 32usize] ;
4968 ["Offset of field: CAPEOPEN_1_2_ICapeArrayBooleanParameterSpecification_VTable::ValidateElement"] [:: std :: mem :: offset_of ! (CAPEOPEN_1_2_ICapeArrayBooleanParameterSpecification_VTable , ValidateElement) - 40usize] ;
4969 ["Offset of field: CAPEOPEN_1_2_ICapeArrayBooleanParameterSpecification_VTable::Validate"][::std::mem::offset_of!(
4970 CAPEOPEN_1_2_ICapeArrayBooleanParameterSpecification_VTable,
4971 Validate
4972 )
4973 - 48usize];
4974};
4975#[repr(C)]
4976#[derive(Debug, Copy, Clone)]
4977pub struct _CAPEOPEN_1_2_ICapeArrayBooleanParameterSpecification {
4978 pub me: *mut ::std::os::raw::c_void,
4979 pub vTbl: *mut CAPEOPEN_1_2_ICapeArrayBooleanParameterSpecification_VTable,
4980}
4981#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4982const _: () = {
4983 ["Size of _CAPEOPEN_1_2_ICapeArrayBooleanParameterSpecification"]
4984 [::std::mem::size_of::<_CAPEOPEN_1_2_ICapeArrayBooleanParameterSpecification>() - 16usize];
4985 ["Alignment of _CAPEOPEN_1_2_ICapeArrayBooleanParameterSpecification"]
4986 [::std::mem::align_of::<_CAPEOPEN_1_2_ICapeArrayBooleanParameterSpecification>() - 8usize];
4987 ["Offset of field: _CAPEOPEN_1_2_ICapeArrayBooleanParameterSpecification::me"][::std::mem::offset_of!(
4988 _CAPEOPEN_1_2_ICapeArrayBooleanParameterSpecification,
4989 me
4990 ) - 0usize];
4991 ["Offset of field: _CAPEOPEN_1_2_ICapeArrayBooleanParameterSpecification::vTbl"][::std::mem::offset_of!(
4992 _CAPEOPEN_1_2_ICapeArrayBooleanParameterSpecification,
4993 vTbl
4994 ) - 8usize];
4995};
4996pub type CAPEOPEN_1_2_ICapeArrayBooleanParameterSpecification =
4997 _CAPEOPEN_1_2_ICapeArrayBooleanParameterSpecification;
4998#[repr(C)]
4999#[derive(Debug, Copy, Clone)]
5000pub struct CAPEOPEN_1_2_ICapeSimulationContext_VTable {
5001 pub base: ICapeInterface_VTable,
5002}
5003#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5004const _: () = {
5005 ["Size of CAPEOPEN_1_2_ICapeSimulationContext_VTable"]
5006 [::std::mem::size_of::<CAPEOPEN_1_2_ICapeSimulationContext_VTable>() - 32usize];
5007 ["Alignment of CAPEOPEN_1_2_ICapeSimulationContext_VTable"]
5008 [::std::mem::align_of::<CAPEOPEN_1_2_ICapeSimulationContext_VTable>() - 8usize];
5009 ["Offset of field: CAPEOPEN_1_2_ICapeSimulationContext_VTable::base"]
5010 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeSimulationContext_VTable, base) - 0usize];
5011};
5012#[repr(C)]
5013#[derive(Debug, Copy, Clone)]
5014pub struct _CAPEOPEN_1_2_ICapeSimulationContext {
5015 pub me: *mut ::std::os::raw::c_void,
5016 pub vTbl: *mut CAPEOPEN_1_2_ICapeSimulationContext_VTable,
5017}
5018#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5019const _: () = {
5020 ["Size of _CAPEOPEN_1_2_ICapeSimulationContext"]
5021 [::std::mem::size_of::<_CAPEOPEN_1_2_ICapeSimulationContext>() - 16usize];
5022 ["Alignment of _CAPEOPEN_1_2_ICapeSimulationContext"]
5023 [::std::mem::align_of::<_CAPEOPEN_1_2_ICapeSimulationContext>() - 8usize];
5024 ["Offset of field: _CAPEOPEN_1_2_ICapeSimulationContext::me"]
5025 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapeSimulationContext, me) - 0usize];
5026 ["Offset of field: _CAPEOPEN_1_2_ICapeSimulationContext::vTbl"]
5027 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapeSimulationContext, vTbl) - 8usize];
5028};
5029pub type CAPEOPEN_1_2_ICapeSimulationContext = _CAPEOPEN_1_2_ICapeSimulationContext;
5030#[repr(C)]
5031#[derive(Debug, Copy, Clone)]
5032pub struct CAPEOPEN_1_2_ICapeUtilities_VTable {
5033 pub base: ICapeInterface_VTable,
5034 pub getParameters: ::std::option::Option<
5035 unsafe extern "C" fn(
5036 me: *mut ::std::os::raw::c_void,
5037 parameters: *mut *mut _CAPEOPEN_1_2_ICapeCollection,
5038 ) -> CapeResult,
5039 >,
5040 pub putSimulationContext: ::std::option::Option<
5041 unsafe extern "C" fn(
5042 me: *mut ::std::os::raw::c_void,
5043 context: *mut _CAPEOPEN_1_2_ICapeSimulationContext,
5044 ) -> CapeResult,
5045 >,
5046 pub Initialize:
5047 ::std::option::Option<unsafe extern "C" fn(me: *mut ::std::os::raw::c_void) -> CapeResult>,
5048 pub Terminate:
5049 ::std::option::Option<unsafe extern "C" fn(me: *mut ::std::os::raw::c_void) -> CapeResult>,
5050 pub Edit: ::std::option::Option<
5051 unsafe extern "C" fn(
5052 me: *mut ::std::os::raw::c_void,
5053 parent: CapeWindowId,
5054 result: *mut CAPEOPEN_1_2_CapeEditResult,
5055 ) -> CapeResult,
5056 >,
5057}
5058#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5059const _: () = {
5060 ["Size of CAPEOPEN_1_2_ICapeUtilities_VTable"]
5061 [::std::mem::size_of::<CAPEOPEN_1_2_ICapeUtilities_VTable>() - 72usize];
5062 ["Alignment of CAPEOPEN_1_2_ICapeUtilities_VTable"]
5063 [::std::mem::align_of::<CAPEOPEN_1_2_ICapeUtilities_VTable>() - 8usize];
5064 ["Offset of field: CAPEOPEN_1_2_ICapeUtilities_VTable::base"]
5065 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeUtilities_VTable, base) - 0usize];
5066 ["Offset of field: CAPEOPEN_1_2_ICapeUtilities_VTable::getParameters"]
5067 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeUtilities_VTable, getParameters) - 32usize];
5068 ["Offset of field: CAPEOPEN_1_2_ICapeUtilities_VTable::putSimulationContext"][::std::mem::offset_of!(
5069 CAPEOPEN_1_2_ICapeUtilities_VTable,
5070 putSimulationContext
5071 ) - 40usize];
5072 ["Offset of field: CAPEOPEN_1_2_ICapeUtilities_VTable::Initialize"]
5073 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeUtilities_VTable, Initialize) - 48usize];
5074 ["Offset of field: CAPEOPEN_1_2_ICapeUtilities_VTable::Terminate"]
5075 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeUtilities_VTable, Terminate) - 56usize];
5076 ["Offset of field: CAPEOPEN_1_2_ICapeUtilities_VTable::Edit"]
5077 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeUtilities_VTable, Edit) - 64usize];
5078};
5079#[repr(C)]
5080#[derive(Debug, Copy, Clone)]
5081pub struct _CAPEOPEN_1_2_ICapeUtilities {
5082 pub me: *mut ::std::os::raw::c_void,
5083 pub vTbl: *mut CAPEOPEN_1_2_ICapeUtilities_VTable,
5084}
5085#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5086const _: () = {
5087 ["Size of _CAPEOPEN_1_2_ICapeUtilities"]
5088 [::std::mem::size_of::<_CAPEOPEN_1_2_ICapeUtilities>() - 16usize];
5089 ["Alignment of _CAPEOPEN_1_2_ICapeUtilities"]
5090 [::std::mem::align_of::<_CAPEOPEN_1_2_ICapeUtilities>() - 8usize];
5091 ["Offset of field: _CAPEOPEN_1_2_ICapeUtilities::me"]
5092 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapeUtilities, me) - 0usize];
5093 ["Offset of field: _CAPEOPEN_1_2_ICapeUtilities::vTbl"]
5094 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapeUtilities, vTbl) - 8usize];
5095};
5096pub type CAPEOPEN_1_2_ICapeUtilities = _CAPEOPEN_1_2_ICapeUtilities;
5097#[repr(C)]
5098#[derive(Debug, Copy, Clone)]
5099pub struct CAPEOPEN_1_2_ICapeDiagnostic_VTable {
5100 pub base: ICapeInterface_VTable,
5101 pub PopUpMessage: ::std::option::Option<
5102 unsafe extern "C" fn(
5103 me: *mut ::std::os::raw::c_void,
5104 message: *mut ICapeString,
5105 ) -> CapeResult,
5106 >,
5107 pub LogMessage: ::std::option::Option<
5108 unsafe extern "C" fn(
5109 me: *mut ::std::os::raw::c_void,
5110 message: *mut ICapeString,
5111 ) -> CapeResult,
5112 >,
5113}
5114#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5115const _: () = {
5116 ["Size of CAPEOPEN_1_2_ICapeDiagnostic_VTable"]
5117 [::std::mem::size_of::<CAPEOPEN_1_2_ICapeDiagnostic_VTable>() - 48usize];
5118 ["Alignment of CAPEOPEN_1_2_ICapeDiagnostic_VTable"]
5119 [::std::mem::align_of::<CAPEOPEN_1_2_ICapeDiagnostic_VTable>() - 8usize];
5120 ["Offset of field: CAPEOPEN_1_2_ICapeDiagnostic_VTable::base"]
5121 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeDiagnostic_VTable, base) - 0usize];
5122 ["Offset of field: CAPEOPEN_1_2_ICapeDiagnostic_VTable::PopUpMessage"]
5123 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeDiagnostic_VTable, PopUpMessage) - 32usize];
5124 ["Offset of field: CAPEOPEN_1_2_ICapeDiagnostic_VTable::LogMessage"]
5125 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeDiagnostic_VTable, LogMessage) - 40usize];
5126};
5127#[repr(C)]
5128#[derive(Debug, Copy, Clone)]
5129pub struct _CAPEOPEN_1_2_ICapeDiagnostic {
5130 pub me: *mut ::std::os::raw::c_void,
5131 pub vTbl: *mut CAPEOPEN_1_2_ICapeDiagnostic_VTable,
5132}
5133#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5134const _: () = {
5135 ["Size of _CAPEOPEN_1_2_ICapeDiagnostic"]
5136 [::std::mem::size_of::<_CAPEOPEN_1_2_ICapeDiagnostic>() - 16usize];
5137 ["Alignment of _CAPEOPEN_1_2_ICapeDiagnostic"]
5138 [::std::mem::align_of::<_CAPEOPEN_1_2_ICapeDiagnostic>() - 8usize];
5139 ["Offset of field: _CAPEOPEN_1_2_ICapeDiagnostic::me"]
5140 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapeDiagnostic, me) - 0usize];
5141 ["Offset of field: _CAPEOPEN_1_2_ICapeDiagnostic::vTbl"]
5142 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapeDiagnostic, vTbl) - 8usize];
5143};
5144pub type CAPEOPEN_1_2_ICapeDiagnostic = _CAPEOPEN_1_2_ICapeDiagnostic;
5145#[repr(C)]
5146#[derive(Debug, Copy, Clone)]
5147pub struct CAPEOPEN_1_2_ICapeMaterialManager_VTable {
5148 pub base: ICapeInterface_VTable,
5149 pub getMaterialList: ::std::option::Option<
5150 unsafe extern "C" fn(
5151 me: *mut ::std::os::raw::c_void,
5152 materialNameList: *mut ICapeArrayString,
5153 ) -> CapeResult,
5154 >,
5155 pub CreateMaterial: ::std::option::Option<
5156 unsafe extern "C" fn(
5157 me: *mut ::std::os::raw::c_void,
5158 materialName: *mut ICapeString,
5159 material: *mut *mut ICapeInterface,
5160 ) -> CapeResult,
5161 >,
5162}
5163#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5164const _: () = {
5165 ["Size of CAPEOPEN_1_2_ICapeMaterialManager_VTable"]
5166 [::std::mem::size_of::<CAPEOPEN_1_2_ICapeMaterialManager_VTable>() - 48usize];
5167 ["Alignment of CAPEOPEN_1_2_ICapeMaterialManager_VTable"]
5168 [::std::mem::align_of::<CAPEOPEN_1_2_ICapeMaterialManager_VTable>() - 8usize];
5169 ["Offset of field: CAPEOPEN_1_2_ICapeMaterialManager_VTable::base"]
5170 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeMaterialManager_VTable, base) - 0usize];
5171 ["Offset of field: CAPEOPEN_1_2_ICapeMaterialManager_VTable::getMaterialList"][::std::mem::offset_of!(
5172 CAPEOPEN_1_2_ICapeMaterialManager_VTable,
5173 getMaterialList
5174 ) - 32usize];
5175 ["Offset of field: CAPEOPEN_1_2_ICapeMaterialManager_VTable::CreateMaterial"][::std::mem::offset_of!(
5176 CAPEOPEN_1_2_ICapeMaterialManager_VTable,
5177 CreateMaterial
5178 ) - 40usize];
5179};
5180#[repr(C)]
5181#[derive(Debug, Copy, Clone)]
5182pub struct _CAPEOPEN_1_2_ICapeMaterialManager {
5183 pub me: *mut ::std::os::raw::c_void,
5184 pub vTbl: *mut CAPEOPEN_1_2_ICapeMaterialManager_VTable,
5185}
5186#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5187const _: () = {
5188 ["Size of _CAPEOPEN_1_2_ICapeMaterialManager"]
5189 [::std::mem::size_of::<_CAPEOPEN_1_2_ICapeMaterialManager>() - 16usize];
5190 ["Alignment of _CAPEOPEN_1_2_ICapeMaterialManager"]
5191 [::std::mem::align_of::<_CAPEOPEN_1_2_ICapeMaterialManager>() - 8usize];
5192 ["Offset of field: _CAPEOPEN_1_2_ICapeMaterialManager::me"]
5193 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapeMaterialManager, me) - 0usize];
5194 ["Offset of field: _CAPEOPEN_1_2_ICapeMaterialManager::vTbl"]
5195 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapeMaterialManager, vTbl) - 8usize];
5196};
5197pub type CAPEOPEN_1_2_ICapeMaterialManager = _CAPEOPEN_1_2_ICapeMaterialManager;
5198#[repr(C)]
5199#[derive(Debug, Copy, Clone)]
5200pub struct CAPEOPEN_1_2_ICapeCOSEUtilities_VTable {
5201 pub base: ICapeInterface_VTable,
5202 pub getNamedValueList: ::std::option::Option<
5203 unsafe extern "C" fn(
5204 me: *mut ::std::os::raw::c_void,
5205 namedValues: *mut ICapeArrayString,
5206 ) -> CapeResult,
5207 >,
5208 pub NamedValue: ::std::option::Option<
5209 unsafe extern "C" fn(
5210 me: *mut ::std::os::raw::c_void,
5211 name: *mut ICapeString,
5212 namedValue: *mut ICapeValue,
5213 ) -> CapeResult,
5214 >,
5215}
5216#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5217const _: () = {
5218 ["Size of CAPEOPEN_1_2_ICapeCOSEUtilities_VTable"]
5219 [::std::mem::size_of::<CAPEOPEN_1_2_ICapeCOSEUtilities_VTable>() - 48usize];
5220 ["Alignment of CAPEOPEN_1_2_ICapeCOSEUtilities_VTable"]
5221 [::std::mem::align_of::<CAPEOPEN_1_2_ICapeCOSEUtilities_VTable>() - 8usize];
5222 ["Offset of field: CAPEOPEN_1_2_ICapeCOSEUtilities_VTable::base"]
5223 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeCOSEUtilities_VTable, base) - 0usize];
5224 ["Offset of field: CAPEOPEN_1_2_ICapeCOSEUtilities_VTable::getNamedValueList"][::std::mem::offset_of!(
5225 CAPEOPEN_1_2_ICapeCOSEUtilities_VTable,
5226 getNamedValueList
5227 ) - 32usize];
5228 ["Offset of field: CAPEOPEN_1_2_ICapeCOSEUtilities_VTable::NamedValue"]
5229 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeCOSEUtilities_VTable, NamedValue) - 40usize];
5230};
5231#[repr(C)]
5232#[derive(Debug, Copy, Clone)]
5233pub struct _CAPEOPEN_1_2_ICapeCOSEUtilities {
5234 pub me: *mut ::std::os::raw::c_void,
5235 pub vTbl: *mut CAPEOPEN_1_2_ICapeCOSEUtilities_VTable,
5236}
5237#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5238const _: () = {
5239 ["Size of _CAPEOPEN_1_2_ICapeCOSEUtilities"]
5240 [::std::mem::size_of::<_CAPEOPEN_1_2_ICapeCOSEUtilities>() - 16usize];
5241 ["Alignment of _CAPEOPEN_1_2_ICapeCOSEUtilities"]
5242 [::std::mem::align_of::<_CAPEOPEN_1_2_ICapeCOSEUtilities>() - 8usize];
5243 ["Offset of field: _CAPEOPEN_1_2_ICapeCOSEUtilities::me"]
5244 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapeCOSEUtilities, me) - 0usize];
5245 ["Offset of field: _CAPEOPEN_1_2_ICapeCOSEUtilities::vTbl"]
5246 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapeCOSEUtilities, vTbl) - 8usize];
5247};
5248pub type CAPEOPEN_1_2_ICapeCOSEUtilities = _CAPEOPEN_1_2_ICapeCOSEUtilities;
5249#[repr(C)]
5250#[derive(Debug, Copy, Clone)]
5251pub struct CAPEOPEN_1_2_ICapeThermoMaterial_VTable {
5252 pub base: ICapeInterface_VTable,
5253 pub ClearAllProps:
5254 ::std::option::Option<unsafe extern "C" fn(me: *mut ::std::os::raw::c_void) -> CapeResult>,
5255 pub CopyFromMaterial: ::std::option::Option<
5256 unsafe extern "C" fn(
5257 me: *mut ::std::os::raw::c_void,
5258 source: *mut _CAPEOPEN_1_2_ICapeThermoMaterial,
5259 ) -> CapeResult,
5260 >,
5261 pub CreateMaterial: ::std::option::Option<
5262 unsafe extern "C" fn(
5263 me: *mut ::std::os::raw::c_void,
5264 materialObject: *mut *mut _CAPEOPEN_1_2_ICapeThermoMaterial,
5265 ) -> CapeResult,
5266 >,
5267 pub GetOverallProp: ::std::option::Option<
5268 unsafe extern "C" fn(
5269 me: *mut ::std::os::raw::c_void,
5270 property: *mut ICapeString,
5271 basis: *mut ICapeString,
5272 results: *mut ICapeArrayReal,
5273 ) -> CapeResult,
5274 >,
5275 pub GetOverallTPFraction: ::std::option::Option<
5276 unsafe extern "C" fn(
5277 me: *mut ::std::os::raw::c_void,
5278 temperature: *mut CapeReal,
5279 pressure: *mut CapeReal,
5280 composition: *mut ICapeArrayReal,
5281 ) -> CapeResult,
5282 >,
5283 pub GetPresentPhases: ::std::option::Option<
5284 unsafe extern "C" fn(
5285 me: *mut ::std::os::raw::c_void,
5286 phaseLabels: *mut ICapeArrayString,
5287 phaseStatus: *mut ICapeArrayEnumeration,
5288 ) -> CapeResult,
5289 >,
5290 pub GetSinglePhaseProp: ::std::option::Option<
5291 unsafe extern "C" fn(
5292 me: *mut ::std::os::raw::c_void,
5293 property: *mut ICapeString,
5294 phaseLabel: *mut ICapeString,
5295 basis: *mut ICapeString,
5296 results: *mut ICapeArrayReal,
5297 ) -> CapeResult,
5298 >,
5299 pub GetTPFraction: ::std::option::Option<
5300 unsafe extern "C" fn(
5301 me: *mut ::std::os::raw::c_void,
5302 phaseLabel: *mut ICapeString,
5303 temperature: *mut CapeReal,
5304 pressure: *mut CapeReal,
5305 composition: *mut ICapeArrayReal,
5306 ) -> CapeResult,
5307 >,
5308 pub GetTwoPhaseProp: ::std::option::Option<
5309 unsafe extern "C" fn(
5310 me: *mut ::std::os::raw::c_void,
5311 property: *mut ICapeString,
5312 phaseLabels: *mut ICapeArrayString,
5313 basis: *mut ICapeString,
5314 results: *mut ICapeArrayReal,
5315 ) -> CapeResult,
5316 >,
5317 pub SetOverallProp: ::std::option::Option<
5318 unsafe extern "C" fn(
5319 me: *mut ::std::os::raw::c_void,
5320 property: *mut ICapeString,
5321 basis: *mut ICapeString,
5322 values: *mut ICapeArrayReal,
5323 ) -> CapeResult,
5324 >,
5325 pub SetPresentPhases: ::std::option::Option<
5326 unsafe extern "C" fn(
5327 me: *mut ::std::os::raw::c_void,
5328 phaseLabels: *mut ICapeArrayString,
5329 phaseStatus: *mut ICapeArrayEnumeration,
5330 ) -> CapeResult,
5331 >,
5332 pub SetSinglePhaseProp: ::std::option::Option<
5333 unsafe extern "C" fn(
5334 me: *mut ::std::os::raw::c_void,
5335 property: *mut ICapeString,
5336 phaseLabel: *mut ICapeString,
5337 basis: *mut ICapeString,
5338 values: *mut ICapeArrayReal,
5339 ) -> CapeResult,
5340 >,
5341 pub SetTwoPhaseProp: ::std::option::Option<
5342 unsafe extern "C" fn(
5343 me: *mut ::std::os::raw::c_void,
5344 property: *mut ICapeString,
5345 phaseLabels: *mut ICapeArrayString,
5346 basis: *mut ICapeString,
5347 values: *mut ICapeArrayReal,
5348 ) -> CapeResult,
5349 >,
5350}
5351#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5352const _: () = {
5353 ["Size of CAPEOPEN_1_2_ICapeThermoMaterial_VTable"]
5354 [::std::mem::size_of::<CAPEOPEN_1_2_ICapeThermoMaterial_VTable>() - 136usize];
5355 ["Alignment of CAPEOPEN_1_2_ICapeThermoMaterial_VTable"]
5356 [::std::mem::align_of::<CAPEOPEN_1_2_ICapeThermoMaterial_VTable>() - 8usize];
5357 ["Offset of field: CAPEOPEN_1_2_ICapeThermoMaterial_VTable::base"]
5358 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeThermoMaterial_VTable, base) - 0usize];
5359 ["Offset of field: CAPEOPEN_1_2_ICapeThermoMaterial_VTable::ClearAllProps"]
5360 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeThermoMaterial_VTable, ClearAllProps) - 32usize];
5361 ["Offset of field: CAPEOPEN_1_2_ICapeThermoMaterial_VTable::CopyFromMaterial"][::std::mem::offset_of!(
5362 CAPEOPEN_1_2_ICapeThermoMaterial_VTable,
5363 CopyFromMaterial
5364 ) - 40usize];
5365 ["Offset of field: CAPEOPEN_1_2_ICapeThermoMaterial_VTable::CreateMaterial"]
5366 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeThermoMaterial_VTable, CreateMaterial) - 48usize];
5367 ["Offset of field: CAPEOPEN_1_2_ICapeThermoMaterial_VTable::GetOverallProp"]
5368 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeThermoMaterial_VTable, GetOverallProp) - 56usize];
5369 ["Offset of field: CAPEOPEN_1_2_ICapeThermoMaterial_VTable::GetOverallTPFraction"][::std::mem::offset_of!(
5370 CAPEOPEN_1_2_ICapeThermoMaterial_VTable,
5371 GetOverallTPFraction
5372 ) - 64usize];
5373 ["Offset of field: CAPEOPEN_1_2_ICapeThermoMaterial_VTable::GetPresentPhases"][::std::mem::offset_of!(
5374 CAPEOPEN_1_2_ICapeThermoMaterial_VTable,
5375 GetPresentPhases
5376 ) - 72usize];
5377 ["Offset of field: CAPEOPEN_1_2_ICapeThermoMaterial_VTable::GetSinglePhaseProp"][::std::mem::offset_of!(
5378 CAPEOPEN_1_2_ICapeThermoMaterial_VTable,
5379 GetSinglePhaseProp
5380 ) - 80usize];
5381 ["Offset of field: CAPEOPEN_1_2_ICapeThermoMaterial_VTable::GetTPFraction"]
5382 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeThermoMaterial_VTable, GetTPFraction) - 88usize];
5383 ["Offset of field: CAPEOPEN_1_2_ICapeThermoMaterial_VTable::GetTwoPhaseProp"][::std::mem::offset_of!(
5384 CAPEOPEN_1_2_ICapeThermoMaterial_VTable,
5385 GetTwoPhaseProp
5386 ) - 96usize];
5387 ["Offset of field: CAPEOPEN_1_2_ICapeThermoMaterial_VTable::SetOverallProp"][::std::mem::offset_of!(
5388 CAPEOPEN_1_2_ICapeThermoMaterial_VTable,
5389 SetOverallProp
5390 ) - 104usize];
5391 ["Offset of field: CAPEOPEN_1_2_ICapeThermoMaterial_VTable::SetPresentPhases"][::std::mem::offset_of!(
5392 CAPEOPEN_1_2_ICapeThermoMaterial_VTable,
5393 SetPresentPhases
5394 ) - 112usize];
5395 ["Offset of field: CAPEOPEN_1_2_ICapeThermoMaterial_VTable::SetSinglePhaseProp"][::std::mem::offset_of!(
5396 CAPEOPEN_1_2_ICapeThermoMaterial_VTable,
5397 SetSinglePhaseProp
5398 ) - 120usize];
5399 ["Offset of field: CAPEOPEN_1_2_ICapeThermoMaterial_VTable::SetTwoPhaseProp"][::std::mem::offset_of!(
5400 CAPEOPEN_1_2_ICapeThermoMaterial_VTable,
5401 SetTwoPhaseProp
5402 ) - 128usize];
5403};
5404#[repr(C)]
5405#[derive(Debug, Copy, Clone)]
5406pub struct _CAPEOPEN_1_2_ICapeThermoMaterial {
5407 pub me: *mut ::std::os::raw::c_void,
5408 pub vTbl: *mut CAPEOPEN_1_2_ICapeThermoMaterial_VTable,
5409}
5410#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5411const _: () = {
5412 ["Size of _CAPEOPEN_1_2_ICapeThermoMaterial"]
5413 [::std::mem::size_of::<_CAPEOPEN_1_2_ICapeThermoMaterial>() - 16usize];
5414 ["Alignment of _CAPEOPEN_1_2_ICapeThermoMaterial"]
5415 [::std::mem::align_of::<_CAPEOPEN_1_2_ICapeThermoMaterial>() - 8usize];
5416 ["Offset of field: _CAPEOPEN_1_2_ICapeThermoMaterial::me"]
5417 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapeThermoMaterial, me) - 0usize];
5418 ["Offset of field: _CAPEOPEN_1_2_ICapeThermoMaterial::vTbl"]
5419 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapeThermoMaterial, vTbl) - 8usize];
5420};
5421pub type CAPEOPEN_1_2_ICapeThermoMaterial = _CAPEOPEN_1_2_ICapeThermoMaterial;
5422#[repr(C)]
5423#[derive(Debug, Copy, Clone)]
5424pub struct CAPEOPEN_1_2_ICapeThermoMaterialContext_VTable {
5425 pub base: ICapeInterface_VTable,
5426 pub SetMaterial: ::std::option::Option<
5427 unsafe extern "C" fn(
5428 me: *mut ::std::os::raw::c_void,
5429 material: *mut _CAPEOPEN_1_2_ICapeThermoMaterial,
5430 ) -> CapeResult,
5431 >,
5432 pub UnsetMaterial:
5433 ::std::option::Option<unsafe extern "C" fn(me: *mut ::std::os::raw::c_void) -> CapeResult>,
5434}
5435#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5436const _: () = {
5437 ["Size of CAPEOPEN_1_2_ICapeThermoMaterialContext_VTable"]
5438 [::std::mem::size_of::<CAPEOPEN_1_2_ICapeThermoMaterialContext_VTable>() - 48usize];
5439 ["Alignment of CAPEOPEN_1_2_ICapeThermoMaterialContext_VTable"]
5440 [::std::mem::align_of::<CAPEOPEN_1_2_ICapeThermoMaterialContext_VTable>() - 8usize];
5441 ["Offset of field: CAPEOPEN_1_2_ICapeThermoMaterialContext_VTable::base"]
5442 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeThermoMaterialContext_VTable, base) - 0usize];
5443 ["Offset of field: CAPEOPEN_1_2_ICapeThermoMaterialContext_VTable::SetMaterial"][::std::mem::offset_of!(
5444 CAPEOPEN_1_2_ICapeThermoMaterialContext_VTable,
5445 SetMaterial
5446 ) - 32usize];
5447 ["Offset of field: CAPEOPEN_1_2_ICapeThermoMaterialContext_VTable::UnsetMaterial"][::std::mem::offset_of!(
5448 CAPEOPEN_1_2_ICapeThermoMaterialContext_VTable,
5449 UnsetMaterial
5450 ) - 40usize];
5451};
5452#[repr(C)]
5453#[derive(Debug, Copy, Clone)]
5454pub struct _CAPEOPEN_1_2_ICapeThermoMaterialContext {
5455 pub me: *mut ::std::os::raw::c_void,
5456 pub vTbl: *mut CAPEOPEN_1_2_ICapeThermoMaterialContext_VTable,
5457}
5458#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5459const _: () = {
5460 ["Size of _CAPEOPEN_1_2_ICapeThermoMaterialContext"]
5461 [::std::mem::size_of::<_CAPEOPEN_1_2_ICapeThermoMaterialContext>() - 16usize];
5462 ["Alignment of _CAPEOPEN_1_2_ICapeThermoMaterialContext"]
5463 [::std::mem::align_of::<_CAPEOPEN_1_2_ICapeThermoMaterialContext>() - 8usize];
5464 ["Offset of field: _CAPEOPEN_1_2_ICapeThermoMaterialContext::me"]
5465 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapeThermoMaterialContext, me) - 0usize];
5466 ["Offset of field: _CAPEOPEN_1_2_ICapeThermoMaterialContext::vTbl"]
5467 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapeThermoMaterialContext, vTbl) - 8usize];
5468};
5469pub type CAPEOPEN_1_2_ICapeThermoMaterialContext = _CAPEOPEN_1_2_ICapeThermoMaterialContext;
5470#[repr(C)]
5471#[derive(Debug, Copy, Clone)]
5472pub struct CAPEOPEN_1_2_ICapeThermoCompounds_VTable {
5473 pub base: ICapeInterface_VTable,
5474 pub GetCompoundConstant: ::std::option::Option<
5475 unsafe extern "C" fn(
5476 me: *mut ::std::os::raw::c_void,
5477 props: *mut ICapeArrayString,
5478 compIds: *mut ICapeArrayString,
5479 containsMissingValues: *mut CapeBoolean,
5480 propVals: *mut ICapeArrayValue,
5481 ) -> CapeResult,
5482 >,
5483 pub GetCompoundList: ::std::option::Option<
5484 unsafe extern "C" fn(
5485 me: *mut ::std::os::raw::c_void,
5486 compIds: *mut ICapeArrayString,
5487 formulae: *mut ICapeArrayString,
5488 names: *mut ICapeArrayString,
5489 boilTemps: *mut ICapeArrayReal,
5490 molwts: *mut ICapeArrayReal,
5491 casnos: *mut ICapeArrayString,
5492 ) -> CapeResult,
5493 >,
5494 pub getConstPropList: ::std::option::Option<
5495 unsafe extern "C" fn(
5496 me: *mut ::std::os::raw::c_void,
5497 props: *mut ICapeArrayString,
5498 ) -> CapeResult,
5499 >,
5500 pub getNumCompounds: ::std::option::Option<
5501 unsafe extern "C" fn(me: *mut ::std::os::raw::c_void, num: *mut CapeInteger) -> CapeResult,
5502 >,
5503 pub GetPDependentProperty: ::std::option::Option<
5504 unsafe extern "C" fn(
5505 me: *mut ::std::os::raw::c_void,
5506 props: *mut ICapeArrayString,
5507 pressure: CapeReal,
5508 compIds: *mut ICapeArrayString,
5509 containsMissingValues: *mut CapeBoolean,
5510 propVals: *mut ICapeArrayReal,
5511 ) -> CapeResult,
5512 >,
5513 pub getPDependentPropList: ::std::option::Option<
5514 unsafe extern "C" fn(
5515 me: *mut ::std::os::raw::c_void,
5516 props: *mut ICapeArrayString,
5517 ) -> CapeResult,
5518 >,
5519 pub GetTDependentProperty: ::std::option::Option<
5520 unsafe extern "C" fn(
5521 me: *mut ::std::os::raw::c_void,
5522 props: *mut ICapeArrayString,
5523 temperature: CapeReal,
5524 compIds: *mut ICapeArrayString,
5525 containsMissingValues: *mut CapeBoolean,
5526 propVals: *mut ICapeArrayReal,
5527 ) -> CapeResult,
5528 >,
5529 pub getTDependentPropList: ::std::option::Option<
5530 unsafe extern "C" fn(
5531 me: *mut ::std::os::raw::c_void,
5532 props: *mut ICapeArrayString,
5533 ) -> CapeResult,
5534 >,
5535}
5536#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5537const _: () = {
5538 ["Size of CAPEOPEN_1_2_ICapeThermoCompounds_VTable"]
5539 [::std::mem::size_of::<CAPEOPEN_1_2_ICapeThermoCompounds_VTable>() - 96usize];
5540 ["Alignment of CAPEOPEN_1_2_ICapeThermoCompounds_VTable"]
5541 [::std::mem::align_of::<CAPEOPEN_1_2_ICapeThermoCompounds_VTable>() - 8usize];
5542 ["Offset of field: CAPEOPEN_1_2_ICapeThermoCompounds_VTable::base"]
5543 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeThermoCompounds_VTable, base) - 0usize];
5544 ["Offset of field: CAPEOPEN_1_2_ICapeThermoCompounds_VTable::GetCompoundConstant"][::std::mem::offset_of!(
5545 CAPEOPEN_1_2_ICapeThermoCompounds_VTable,
5546 GetCompoundConstant
5547 ) - 32usize];
5548 ["Offset of field: CAPEOPEN_1_2_ICapeThermoCompounds_VTable::GetCompoundList"][::std::mem::offset_of!(
5549 CAPEOPEN_1_2_ICapeThermoCompounds_VTable,
5550 GetCompoundList
5551 ) - 40usize];
5552 ["Offset of field: CAPEOPEN_1_2_ICapeThermoCompounds_VTable::getConstPropList"][::std::mem::offset_of!(
5553 CAPEOPEN_1_2_ICapeThermoCompounds_VTable,
5554 getConstPropList
5555 ) - 48usize];
5556 ["Offset of field: CAPEOPEN_1_2_ICapeThermoCompounds_VTable::getNumCompounds"][::std::mem::offset_of!(
5557 CAPEOPEN_1_2_ICapeThermoCompounds_VTable,
5558 getNumCompounds
5559 ) - 56usize];
5560 ["Offset of field: CAPEOPEN_1_2_ICapeThermoCompounds_VTable::GetPDependentProperty"][::std::mem::offset_of!(
5561 CAPEOPEN_1_2_ICapeThermoCompounds_VTable,
5562 GetPDependentProperty
5563 )
5564 - 64usize];
5565 ["Offset of field: CAPEOPEN_1_2_ICapeThermoCompounds_VTable::getPDependentPropList"][::std::mem::offset_of!(
5566 CAPEOPEN_1_2_ICapeThermoCompounds_VTable,
5567 getPDependentPropList
5568 )
5569 - 72usize];
5570 ["Offset of field: CAPEOPEN_1_2_ICapeThermoCompounds_VTable::GetTDependentProperty"][::std::mem::offset_of!(
5571 CAPEOPEN_1_2_ICapeThermoCompounds_VTable,
5572 GetTDependentProperty
5573 )
5574 - 80usize];
5575 ["Offset of field: CAPEOPEN_1_2_ICapeThermoCompounds_VTable::getTDependentPropList"][::std::mem::offset_of!(
5576 CAPEOPEN_1_2_ICapeThermoCompounds_VTable,
5577 getTDependentPropList
5578 )
5579 - 88usize];
5580};
5581#[repr(C)]
5582#[derive(Debug, Copy, Clone)]
5583pub struct _CAPEOPEN_1_2_ICapeThermoCompounds {
5584 pub me: *mut ::std::os::raw::c_void,
5585 pub vTbl: *mut CAPEOPEN_1_2_ICapeThermoCompounds_VTable,
5586}
5587#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5588const _: () = {
5589 ["Size of _CAPEOPEN_1_2_ICapeThermoCompounds"]
5590 [::std::mem::size_of::<_CAPEOPEN_1_2_ICapeThermoCompounds>() - 16usize];
5591 ["Alignment of _CAPEOPEN_1_2_ICapeThermoCompounds"]
5592 [::std::mem::align_of::<_CAPEOPEN_1_2_ICapeThermoCompounds>() - 8usize];
5593 ["Offset of field: _CAPEOPEN_1_2_ICapeThermoCompounds::me"]
5594 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapeThermoCompounds, me) - 0usize];
5595 ["Offset of field: _CAPEOPEN_1_2_ICapeThermoCompounds::vTbl"]
5596 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapeThermoCompounds, vTbl) - 8usize];
5597};
5598pub type CAPEOPEN_1_2_ICapeThermoCompounds = _CAPEOPEN_1_2_ICapeThermoCompounds;
5599#[repr(C)]
5600#[derive(Debug, Copy, Clone)]
5601pub struct CAPEOPEN_1_2_ICapeThermoPhases_VTable {
5602 pub base: ICapeInterface_VTable,
5603 pub getNumPhases: ::std::option::Option<
5604 unsafe extern "C" fn(me: *mut ::std::os::raw::c_void, num: *mut CapeInteger) -> CapeResult,
5605 >,
5606 pub GetPhaseInfo: ::std::option::Option<
5607 unsafe extern "C" fn(
5608 me: *mut ::std::os::raw::c_void,
5609 phaseLabel: *mut ICapeString,
5610 phaseAttribute: *mut ICapeString,
5611 value: *mut ICapeValue,
5612 ) -> CapeResult,
5613 >,
5614 pub GetPhaseList: ::std::option::Option<
5615 unsafe extern "C" fn(
5616 me: *mut ::std::os::raw::c_void,
5617 phaseLabels: *mut ICapeArrayString,
5618 stateOfAggregation: *mut ICapeArrayString,
5619 keyCompoundId: *mut ICapeArrayString,
5620 ) -> CapeResult,
5621 >,
5622}
5623#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5624const _: () = {
5625 ["Size of CAPEOPEN_1_2_ICapeThermoPhases_VTable"]
5626 [::std::mem::size_of::<CAPEOPEN_1_2_ICapeThermoPhases_VTable>() - 56usize];
5627 ["Alignment of CAPEOPEN_1_2_ICapeThermoPhases_VTable"]
5628 [::std::mem::align_of::<CAPEOPEN_1_2_ICapeThermoPhases_VTable>() - 8usize];
5629 ["Offset of field: CAPEOPEN_1_2_ICapeThermoPhases_VTable::base"]
5630 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeThermoPhases_VTable, base) - 0usize];
5631 ["Offset of field: CAPEOPEN_1_2_ICapeThermoPhases_VTable::getNumPhases"]
5632 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeThermoPhases_VTable, getNumPhases) - 32usize];
5633 ["Offset of field: CAPEOPEN_1_2_ICapeThermoPhases_VTable::GetPhaseInfo"]
5634 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeThermoPhases_VTable, GetPhaseInfo) - 40usize];
5635 ["Offset of field: CAPEOPEN_1_2_ICapeThermoPhases_VTable::GetPhaseList"]
5636 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeThermoPhases_VTable, GetPhaseList) - 48usize];
5637};
5638#[repr(C)]
5639#[derive(Debug, Copy, Clone)]
5640pub struct _CAPEOPEN_1_2_ICapeThermoPhases {
5641 pub me: *mut ::std::os::raw::c_void,
5642 pub vTbl: *mut CAPEOPEN_1_2_ICapeThermoPhases_VTable,
5643}
5644#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5645const _: () = {
5646 ["Size of _CAPEOPEN_1_2_ICapeThermoPhases"]
5647 [::std::mem::size_of::<_CAPEOPEN_1_2_ICapeThermoPhases>() - 16usize];
5648 ["Alignment of _CAPEOPEN_1_2_ICapeThermoPhases"]
5649 [::std::mem::align_of::<_CAPEOPEN_1_2_ICapeThermoPhases>() - 8usize];
5650 ["Offset of field: _CAPEOPEN_1_2_ICapeThermoPhases::me"]
5651 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapeThermoPhases, me) - 0usize];
5652 ["Offset of field: _CAPEOPEN_1_2_ICapeThermoPhases::vTbl"]
5653 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapeThermoPhases, vTbl) - 8usize];
5654};
5655pub type CAPEOPEN_1_2_ICapeThermoPhases = _CAPEOPEN_1_2_ICapeThermoPhases;
5656#[repr(C)]
5657#[derive(Debug, Copy, Clone)]
5658pub struct CAPEOPEN_1_2_ICapeThermoPropertyRoutine_VTable {
5659 pub base: ICapeInterface_VTable,
5660 pub CalcAndGetLnPhi: ::std::option::Option<
5661 unsafe extern "C" fn(
5662 me: *mut ::std::os::raw::c_void,
5663 phaseLabel: *mut ICapeString,
5664 temperature: CapeReal,
5665 pressure: CapeReal,
5666 moleFraction: *mut ICapeArrayReal,
5667 fFlags: CapeInteger,
5668 lnPhi: *mut ICapeArrayReal,
5669 lnPhiDT: *mut ICapeArrayReal,
5670 lnPhiDP: *mut ICapeArrayReal,
5671 lnPhiDn: *mut ICapeArrayReal,
5672 ) -> CapeResult,
5673 >,
5674 pub CalcSinglePhaseProp: ::std::option::Option<
5675 unsafe extern "C" fn(
5676 me: *mut ::std::os::raw::c_void,
5677 props: *mut ICapeArrayString,
5678 phaseLabel: *mut ICapeString,
5679 ) -> CapeResult,
5680 >,
5681 pub CalcTwoPhaseProp: ::std::option::Option<
5682 unsafe extern "C" fn(
5683 me: *mut ::std::os::raw::c_void,
5684 props: *mut ICapeArrayString,
5685 phaseLabels: *mut ICapeArrayString,
5686 ) -> CapeResult,
5687 >,
5688 pub CheckSinglePhasePropSpec: ::std::option::Option<
5689 unsafe extern "C" fn(
5690 me: *mut ::std::os::raw::c_void,
5691 property: *mut ICapeString,
5692 phaseLabel: *mut ICapeString,
5693 valid: *mut CapeBoolean,
5694 ) -> CapeResult,
5695 >,
5696 pub CheckTwoPhasePropSpec: ::std::option::Option<
5697 unsafe extern "C" fn(
5698 me: *mut ::std::os::raw::c_void,
5699 property: *mut ICapeString,
5700 phaseLabels: *mut ICapeArrayString,
5701 valid: *mut CapeBoolean,
5702 ) -> CapeResult,
5703 >,
5704 pub getSinglePhasePropList: ::std::option::Option<
5705 unsafe extern "C" fn(
5706 me: *mut ::std::os::raw::c_void,
5707 props: *mut ICapeArrayString,
5708 ) -> CapeResult,
5709 >,
5710 pub getTwoPhasePropList: ::std::option::Option<
5711 unsafe extern "C" fn(
5712 me: *mut ::std::os::raw::c_void,
5713 props: *mut ICapeArrayString,
5714 ) -> CapeResult,
5715 >,
5716}
5717#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5718const _: () = {
5719 ["Size of CAPEOPEN_1_2_ICapeThermoPropertyRoutine_VTable"]
5720 [::std::mem::size_of::<CAPEOPEN_1_2_ICapeThermoPropertyRoutine_VTable>() - 88usize];
5721 ["Alignment of CAPEOPEN_1_2_ICapeThermoPropertyRoutine_VTable"]
5722 [::std::mem::align_of::<CAPEOPEN_1_2_ICapeThermoPropertyRoutine_VTable>() - 8usize];
5723 ["Offset of field: CAPEOPEN_1_2_ICapeThermoPropertyRoutine_VTable::base"]
5724 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeThermoPropertyRoutine_VTable, base) - 0usize];
5725 ["Offset of field: CAPEOPEN_1_2_ICapeThermoPropertyRoutine_VTable::CalcAndGetLnPhi"][::std::mem::offset_of!(
5726 CAPEOPEN_1_2_ICapeThermoPropertyRoutine_VTable,
5727 CalcAndGetLnPhi
5728 )
5729 - 32usize];
5730 ["Offset of field: CAPEOPEN_1_2_ICapeThermoPropertyRoutine_VTable::CalcSinglePhaseProp"][::std::mem::offset_of!(
5731 CAPEOPEN_1_2_ICapeThermoPropertyRoutine_VTable,
5732 CalcSinglePhaseProp
5733 )
5734 - 40usize];
5735 ["Offset of field: CAPEOPEN_1_2_ICapeThermoPropertyRoutine_VTable::CalcTwoPhaseProp"][::std::mem::offset_of!(
5736 CAPEOPEN_1_2_ICapeThermoPropertyRoutine_VTable,
5737 CalcTwoPhaseProp
5738 )
5739 - 48usize];
5740 ["Offset of field: CAPEOPEN_1_2_ICapeThermoPropertyRoutine_VTable::CheckSinglePhasePropSpec"][::std::mem::offset_of!(
5741 CAPEOPEN_1_2_ICapeThermoPropertyRoutine_VTable,
5742 CheckSinglePhasePropSpec
5743 )
5744 - 56usize];
5745 ["Offset of field: CAPEOPEN_1_2_ICapeThermoPropertyRoutine_VTable::CheckTwoPhasePropSpec"][::std::mem::offset_of!(
5746 CAPEOPEN_1_2_ICapeThermoPropertyRoutine_VTable,
5747 CheckTwoPhasePropSpec
5748 )
5749 - 64usize];
5750 ["Offset of field: CAPEOPEN_1_2_ICapeThermoPropertyRoutine_VTable::getSinglePhasePropList"][::std::mem::offset_of!(
5751 CAPEOPEN_1_2_ICapeThermoPropertyRoutine_VTable,
5752 getSinglePhasePropList
5753 )
5754 - 72usize];
5755 ["Offset of field: CAPEOPEN_1_2_ICapeThermoPropertyRoutine_VTable::getTwoPhasePropList"][::std::mem::offset_of!(
5756 CAPEOPEN_1_2_ICapeThermoPropertyRoutine_VTable,
5757 getTwoPhasePropList
5758 )
5759 - 80usize];
5760};
5761#[repr(C)]
5762#[derive(Debug, Copy, Clone)]
5763pub struct _CAPEOPEN_1_2_ICapeThermoPropertyRoutine {
5764 pub me: *mut ::std::os::raw::c_void,
5765 pub vTbl: *mut CAPEOPEN_1_2_ICapeThermoPropertyRoutine_VTable,
5766}
5767#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5768const _: () = {
5769 ["Size of _CAPEOPEN_1_2_ICapeThermoPropertyRoutine"]
5770 [::std::mem::size_of::<_CAPEOPEN_1_2_ICapeThermoPropertyRoutine>() - 16usize];
5771 ["Alignment of _CAPEOPEN_1_2_ICapeThermoPropertyRoutine"]
5772 [::std::mem::align_of::<_CAPEOPEN_1_2_ICapeThermoPropertyRoutine>() - 8usize];
5773 ["Offset of field: _CAPEOPEN_1_2_ICapeThermoPropertyRoutine::me"]
5774 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapeThermoPropertyRoutine, me) - 0usize];
5775 ["Offset of field: _CAPEOPEN_1_2_ICapeThermoPropertyRoutine::vTbl"]
5776 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapeThermoPropertyRoutine, vTbl) - 8usize];
5777};
5778pub type CAPEOPEN_1_2_ICapeThermoPropertyRoutine = _CAPEOPEN_1_2_ICapeThermoPropertyRoutine;
5779#[repr(C)]
5780#[derive(Debug, Copy, Clone)]
5781pub struct CAPEOPEN_1_2_ICapeThermoEquilibriumRoutine_VTable {
5782 pub base: ICapeInterface_VTable,
5783 pub CalcEquilibrium: ::std::option::Option<
5784 unsafe extern "C" fn(
5785 me: *mut ::std::os::raw::c_void,
5786 specification1: *mut ICapeArrayString,
5787 specification2: *mut ICapeArrayString,
5788 solutionType: *mut ICapeString,
5789 ) -> CapeResult,
5790 >,
5791 pub CheckEquilibriumSpec: ::std::option::Option<
5792 unsafe extern "C" fn(
5793 me: *mut ::std::os::raw::c_void,
5794 specification1: *mut ICapeArrayString,
5795 specification2: *mut ICapeArrayString,
5796 solutionType: *mut ICapeString,
5797 isSupported: *mut CapeBoolean,
5798 ) -> CapeResult,
5799 >,
5800}
5801#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5802const _: () = {
5803 ["Size of CAPEOPEN_1_2_ICapeThermoEquilibriumRoutine_VTable"]
5804 [::std::mem::size_of::<CAPEOPEN_1_2_ICapeThermoEquilibriumRoutine_VTable>() - 48usize];
5805 ["Alignment of CAPEOPEN_1_2_ICapeThermoEquilibriumRoutine_VTable"]
5806 [::std::mem::align_of::<CAPEOPEN_1_2_ICapeThermoEquilibriumRoutine_VTable>() - 8usize];
5807 ["Offset of field: CAPEOPEN_1_2_ICapeThermoEquilibriumRoutine_VTable::base"]
5808 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeThermoEquilibriumRoutine_VTable, base) - 0usize];
5809 ["Offset of field: CAPEOPEN_1_2_ICapeThermoEquilibriumRoutine_VTable::CalcEquilibrium"][::std::mem::offset_of!(
5810 CAPEOPEN_1_2_ICapeThermoEquilibriumRoutine_VTable,
5811 CalcEquilibrium
5812 )
5813 - 32usize];
5814 ["Offset of field: CAPEOPEN_1_2_ICapeThermoEquilibriumRoutine_VTable::CheckEquilibriumSpec"][::std::mem::offset_of!(
5815 CAPEOPEN_1_2_ICapeThermoEquilibriumRoutine_VTable,
5816 CheckEquilibriumSpec
5817 )
5818 - 40usize];
5819};
5820#[repr(C)]
5821#[derive(Debug, Copy, Clone)]
5822pub struct _CAPEOPEN_1_2_ICapeThermoEquilibriumRoutine {
5823 pub me: *mut ::std::os::raw::c_void,
5824 pub vTbl: *mut CAPEOPEN_1_2_ICapeThermoEquilibriumRoutine_VTable,
5825}
5826#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5827const _: () = {
5828 ["Size of _CAPEOPEN_1_2_ICapeThermoEquilibriumRoutine"]
5829 [::std::mem::size_of::<_CAPEOPEN_1_2_ICapeThermoEquilibriumRoutine>() - 16usize];
5830 ["Alignment of _CAPEOPEN_1_2_ICapeThermoEquilibriumRoutine"]
5831 [::std::mem::align_of::<_CAPEOPEN_1_2_ICapeThermoEquilibriumRoutine>() - 8usize];
5832 ["Offset of field: _CAPEOPEN_1_2_ICapeThermoEquilibriumRoutine::me"]
5833 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapeThermoEquilibriumRoutine, me) - 0usize];
5834 ["Offset of field: _CAPEOPEN_1_2_ICapeThermoEquilibriumRoutine::vTbl"]
5835 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapeThermoEquilibriumRoutine, vTbl) - 8usize];
5836};
5837pub type CAPEOPEN_1_2_ICapeThermoEquilibriumRoutine = _CAPEOPEN_1_2_ICapeThermoEquilibriumRoutine;
5838#[repr(C)]
5839#[derive(Debug, Copy, Clone)]
5840pub struct CAPEOPEN_1_2_ICapeThermoUniversalConstant_VTable {
5841 pub base: ICapeInterface_VTable,
5842 pub GetUniversalConstant: ::std::option::Option<
5843 unsafe extern "C" fn(
5844 me: *mut ::std::os::raw::c_void,
5845 constantId: *mut ICapeString,
5846 constantValue: *mut ICapeValue,
5847 ) -> CapeResult,
5848 >,
5849 pub getUniversalConstantList: ::std::option::Option<
5850 unsafe extern "C" fn(
5851 me: *mut ::std::os::raw::c_void,
5852 constantIdList: *mut ICapeArrayString,
5853 ) -> CapeResult,
5854 >,
5855}
5856#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5857const _: () = {
5858 ["Size of CAPEOPEN_1_2_ICapeThermoUniversalConstant_VTable"]
5859 [::std::mem::size_of::<CAPEOPEN_1_2_ICapeThermoUniversalConstant_VTable>() - 48usize];
5860 ["Alignment of CAPEOPEN_1_2_ICapeThermoUniversalConstant_VTable"]
5861 [::std::mem::align_of::<CAPEOPEN_1_2_ICapeThermoUniversalConstant_VTable>() - 8usize];
5862 ["Offset of field: CAPEOPEN_1_2_ICapeThermoUniversalConstant_VTable::base"]
5863 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeThermoUniversalConstant_VTable, base) - 0usize];
5864 ["Offset of field: CAPEOPEN_1_2_ICapeThermoUniversalConstant_VTable::GetUniversalConstant"][::std::mem::offset_of!(
5865 CAPEOPEN_1_2_ICapeThermoUniversalConstant_VTable,
5866 GetUniversalConstant
5867 )
5868 - 32usize];
5869 ["Offset of field: CAPEOPEN_1_2_ICapeThermoUniversalConstant_VTable::getUniversalConstantList"] [:: std :: mem :: offset_of ! (CAPEOPEN_1_2_ICapeThermoUniversalConstant_VTable , getUniversalConstantList) - 40usize] ;
5870};
5871#[repr(C)]
5872#[derive(Debug, Copy, Clone)]
5873pub struct _CAPEOPEN_1_2_ICapeThermoUniversalConstant {
5874 pub me: *mut ::std::os::raw::c_void,
5875 pub vTbl: *mut CAPEOPEN_1_2_ICapeThermoUniversalConstant_VTable,
5876}
5877#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5878const _: () = {
5879 ["Size of _CAPEOPEN_1_2_ICapeThermoUniversalConstant"]
5880 [::std::mem::size_of::<_CAPEOPEN_1_2_ICapeThermoUniversalConstant>() - 16usize];
5881 ["Alignment of _CAPEOPEN_1_2_ICapeThermoUniversalConstant"]
5882 [::std::mem::align_of::<_CAPEOPEN_1_2_ICapeThermoUniversalConstant>() - 8usize];
5883 ["Offset of field: _CAPEOPEN_1_2_ICapeThermoUniversalConstant::me"]
5884 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapeThermoUniversalConstant, me) - 0usize];
5885 ["Offset of field: _CAPEOPEN_1_2_ICapeThermoUniversalConstant::vTbl"]
5886 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapeThermoUniversalConstant, vTbl) - 8usize];
5887};
5888pub type CAPEOPEN_1_2_ICapeThermoUniversalConstant = _CAPEOPEN_1_2_ICapeThermoUniversalConstant;
5889#[repr(C)]
5890#[derive(Debug, Copy, Clone)]
5891pub struct CAPEOPEN_1_2_ICapeThermoPropertyPackageManager_VTable {
5892 pub base: ICapeInterface_VTable,
5893 pub getPropertyPackageList: ::std::option::Option<
5894 unsafe extern "C" fn(
5895 me: *mut ::std::os::raw::c_void,
5896 PackageNames: *mut ICapeArrayString,
5897 ) -> CapeResult,
5898 >,
5899 pub GetPropertyPackage: ::std::option::Option<
5900 unsafe extern "C" fn(
5901 me: *mut ::std::os::raw::c_void,
5902 PackageName: *mut ICapeString,
5903 package: *mut *mut ICapeInterface,
5904 ) -> CapeResult,
5905 >,
5906}
5907#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5908const _: () = {
5909 ["Size of CAPEOPEN_1_2_ICapeThermoPropertyPackageManager_VTable"]
5910 [::std::mem::size_of::<CAPEOPEN_1_2_ICapeThermoPropertyPackageManager_VTable>() - 48usize];
5911 ["Alignment of CAPEOPEN_1_2_ICapeThermoPropertyPackageManager_VTable"]
5912 [::std::mem::align_of::<CAPEOPEN_1_2_ICapeThermoPropertyPackageManager_VTable>() - 8usize];
5913 ["Offset of field: CAPEOPEN_1_2_ICapeThermoPropertyPackageManager_VTable::base"][::std::mem::offset_of!(
5914 CAPEOPEN_1_2_ICapeThermoPropertyPackageManager_VTable,
5915 base
5916 ) - 0usize];
5917 ["Offset of field: CAPEOPEN_1_2_ICapeThermoPropertyPackageManager_VTable::getPropertyPackageList"] [:: std :: mem :: offset_of ! (CAPEOPEN_1_2_ICapeThermoPropertyPackageManager_VTable , getPropertyPackageList) - 32usize] ;
5918 ["Offset of field: CAPEOPEN_1_2_ICapeThermoPropertyPackageManager_VTable::GetPropertyPackage"] [:: std :: mem :: offset_of ! (CAPEOPEN_1_2_ICapeThermoPropertyPackageManager_VTable , GetPropertyPackage) - 40usize] ;
5919};
5920#[repr(C)]
5921#[derive(Debug, Copy, Clone)]
5922pub struct _CAPEOPEN_1_2_ICapeThermoPropertyPackageManager {
5923 pub me: *mut ::std::os::raw::c_void,
5924 pub vTbl: *mut CAPEOPEN_1_2_ICapeThermoPropertyPackageManager_VTable,
5925}
5926#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5927const _: () = {
5928 ["Size of _CAPEOPEN_1_2_ICapeThermoPropertyPackageManager"]
5929 [::std::mem::size_of::<_CAPEOPEN_1_2_ICapeThermoPropertyPackageManager>() - 16usize];
5930 ["Alignment of _CAPEOPEN_1_2_ICapeThermoPropertyPackageManager"]
5931 [::std::mem::align_of::<_CAPEOPEN_1_2_ICapeThermoPropertyPackageManager>() - 8usize];
5932 ["Offset of field: _CAPEOPEN_1_2_ICapeThermoPropertyPackageManager::me"]
5933 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapeThermoPropertyPackageManager, me) - 0usize];
5934 ["Offset of field: _CAPEOPEN_1_2_ICapeThermoPropertyPackageManager::vTbl"]
5935 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapeThermoPropertyPackageManager, vTbl) - 8usize];
5936};
5937pub type CAPEOPEN_1_2_ICapeThermoPropertyPackageManager =
5938 _CAPEOPEN_1_2_ICapeThermoPropertyPackageManager;
5939#[repr(C)]
5940#[derive(Debug, Copy, Clone)]
5941pub struct CAPEOPEN_1_2_ICapeUnitPort_VTable {
5942 pub base: ICapeInterface_VTable,
5943 pub getPortType: ::std::option::Option<
5944 unsafe extern "C" fn(
5945 me: *mut ::std::os::raw::c_void,
5946 portType: *mut CAPEOPEN_1_2_CapePortType,
5947 ) -> CapeResult,
5948 >,
5949 pub getDirection: ::std::option::Option<
5950 unsafe extern "C" fn(
5951 me: *mut ::std::os::raw::c_void,
5952 portDirection: *mut CAPEOPEN_1_2_CapePortDirection,
5953 ) -> CapeResult,
5954 >,
5955 pub getConnectedObject: ::std::option::Option<
5956 unsafe extern "C" fn(
5957 me: *mut ::std::os::raw::c_void,
5958 connectedObject: *mut *mut ICapeInterface,
5959 ) -> CapeResult,
5960 >,
5961 pub Connect: ::std::option::Option<
5962 unsafe extern "C" fn(
5963 me: *mut ::std::os::raw::c_void,
5964 objectToConnect: *mut ICapeInterface,
5965 ) -> CapeResult,
5966 >,
5967 pub Disconnect:
5968 ::std::option::Option<unsafe extern "C" fn(me: *mut ::std::os::raw::c_void) -> CapeResult>,
5969}
5970#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5971const _: () = {
5972 ["Size of CAPEOPEN_1_2_ICapeUnitPort_VTable"]
5973 [::std::mem::size_of::<CAPEOPEN_1_2_ICapeUnitPort_VTable>() - 72usize];
5974 ["Alignment of CAPEOPEN_1_2_ICapeUnitPort_VTable"]
5975 [::std::mem::align_of::<CAPEOPEN_1_2_ICapeUnitPort_VTable>() - 8usize];
5976 ["Offset of field: CAPEOPEN_1_2_ICapeUnitPort_VTable::base"]
5977 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeUnitPort_VTable, base) - 0usize];
5978 ["Offset of field: CAPEOPEN_1_2_ICapeUnitPort_VTable::getPortType"]
5979 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeUnitPort_VTable, getPortType) - 32usize];
5980 ["Offset of field: CAPEOPEN_1_2_ICapeUnitPort_VTable::getDirection"]
5981 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeUnitPort_VTable, getDirection) - 40usize];
5982 ["Offset of field: CAPEOPEN_1_2_ICapeUnitPort_VTable::getConnectedObject"]
5983 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeUnitPort_VTable, getConnectedObject) - 48usize];
5984 ["Offset of field: CAPEOPEN_1_2_ICapeUnitPort_VTable::Connect"]
5985 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeUnitPort_VTable, Connect) - 56usize];
5986 ["Offset of field: CAPEOPEN_1_2_ICapeUnitPort_VTable::Disconnect"]
5987 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeUnitPort_VTable, Disconnect) - 64usize];
5988};
5989#[repr(C)]
5990#[derive(Debug, Copy, Clone)]
5991pub struct _CAPEOPEN_1_2_ICapeUnitPort {
5992 pub me: *mut ::std::os::raw::c_void,
5993 pub vTbl: *mut CAPEOPEN_1_2_ICapeUnitPort_VTable,
5994}
5995#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5996const _: () = {
5997 ["Size of _CAPEOPEN_1_2_ICapeUnitPort"]
5998 [::std::mem::size_of::<_CAPEOPEN_1_2_ICapeUnitPort>() - 16usize];
5999 ["Alignment of _CAPEOPEN_1_2_ICapeUnitPort"]
6000 [::std::mem::align_of::<_CAPEOPEN_1_2_ICapeUnitPort>() - 8usize];
6001 ["Offset of field: _CAPEOPEN_1_2_ICapeUnitPort::me"]
6002 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapeUnitPort, me) - 0usize];
6003 ["Offset of field: _CAPEOPEN_1_2_ICapeUnitPort::vTbl"]
6004 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapeUnitPort, vTbl) - 8usize];
6005};
6006pub type CAPEOPEN_1_2_ICapeUnitPort = _CAPEOPEN_1_2_ICapeUnitPort;
6007#[repr(C)]
6008#[derive(Debug, Copy, Clone)]
6009pub struct CAPEOPEN_1_2_ICapeUnit_VTable {
6010 pub base: ICapeInterface_VTable,
6011 pub ports: ::std::option::Option<
6012 unsafe extern "C" fn(
6013 me: *mut ::std::os::raw::c_void,
6014 ports: *mut *mut _CAPEOPEN_1_2_ICapeCollection,
6015 ) -> CapeResult,
6016 >,
6017 pub getValStatus: ::std::option::Option<
6018 unsafe extern "C" fn(
6019 me: *mut ::std::os::raw::c_void,
6020 ValStatus: *mut CAPEOPEN_1_2_CapeValidationStatus,
6021 ) -> CapeResult,
6022 >,
6023 pub Calculate:
6024 ::std::option::Option<unsafe extern "C" fn(me: *mut ::std::os::raw::c_void) -> CapeResult>,
6025 pub Validate: ::std::option::Option<
6026 unsafe extern "C" fn(
6027 me: *mut ::std::os::raw::c_void,
6028 message: *mut ICapeString,
6029 isValid: *mut CapeBoolean,
6030 ) -> CapeResult,
6031 >,
6032}
6033#[allow(clippy::unnecessary_operation, clippy::identity_op)]
6034const _: () = {
6035 ["Size of CAPEOPEN_1_2_ICapeUnit_VTable"]
6036 [::std::mem::size_of::<CAPEOPEN_1_2_ICapeUnit_VTable>() - 64usize];
6037 ["Alignment of CAPEOPEN_1_2_ICapeUnit_VTable"]
6038 [::std::mem::align_of::<CAPEOPEN_1_2_ICapeUnit_VTable>() - 8usize];
6039 ["Offset of field: CAPEOPEN_1_2_ICapeUnit_VTable::base"]
6040 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeUnit_VTable, base) - 0usize];
6041 ["Offset of field: CAPEOPEN_1_2_ICapeUnit_VTable::ports"]
6042 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeUnit_VTable, ports) - 32usize];
6043 ["Offset of field: CAPEOPEN_1_2_ICapeUnit_VTable::getValStatus"]
6044 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeUnit_VTable, getValStatus) - 40usize];
6045 ["Offset of field: CAPEOPEN_1_2_ICapeUnit_VTable::Calculate"]
6046 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeUnit_VTable, Calculate) - 48usize];
6047 ["Offset of field: CAPEOPEN_1_2_ICapeUnit_VTable::Validate"]
6048 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeUnit_VTable, Validate) - 56usize];
6049};
6050#[repr(C)]
6051#[derive(Debug, Copy, Clone)]
6052pub struct _CAPEOPEN_1_2_ICapeUnit {
6053 pub me: *mut ::std::os::raw::c_void,
6054 pub vTbl: *mut CAPEOPEN_1_2_ICapeUnit_VTable,
6055}
6056#[allow(clippy::unnecessary_operation, clippy::identity_op)]
6057const _: () = {
6058 ["Size of _CAPEOPEN_1_2_ICapeUnit"][::std::mem::size_of::<_CAPEOPEN_1_2_ICapeUnit>() - 16usize];
6059 ["Alignment of _CAPEOPEN_1_2_ICapeUnit"]
6060 [::std::mem::align_of::<_CAPEOPEN_1_2_ICapeUnit>() - 8usize];
6061 ["Offset of field: _CAPEOPEN_1_2_ICapeUnit::me"]
6062 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapeUnit, me) - 0usize];
6063 ["Offset of field: _CAPEOPEN_1_2_ICapeUnit::vTbl"]
6064 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapeUnit, vTbl) - 8usize];
6065};
6066pub type CAPEOPEN_1_2_ICapeUnit = _CAPEOPEN_1_2_ICapeUnit;
6067#[repr(C)]
6068#[derive(Debug, Copy, Clone)]
6069pub struct CAPEOPEN_1_2_ICapePersistWriter_VTable {
6070 pub base: ICapeInterface_VTable,
6071 pub AddReal: ::std::option::Option<
6072 unsafe extern "C" fn(
6073 me: *mut ::std::os::raw::c_void,
6074 valueName: *mut ICapeString,
6075 value: CapeReal,
6076 ) -> CapeResult,
6077 >,
6078 pub AddInteger: ::std::option::Option<
6079 unsafe extern "C" fn(
6080 me: *mut ::std::os::raw::c_void,
6081 valueName: *mut ICapeString,
6082 value: CapeInteger,
6083 ) -> CapeResult,
6084 >,
6085 pub AddBoolean: ::std::option::Option<
6086 unsafe extern "C" fn(
6087 me: *mut ::std::os::raw::c_void,
6088 valueName: *mut ICapeString,
6089 value: CapeBoolean,
6090 ) -> CapeResult,
6091 >,
6092 pub AddString: ::std::option::Option<
6093 unsafe extern "C" fn(
6094 me: *mut ::std::os::raw::c_void,
6095 valueName: *mut ICapeString,
6096 value: *mut ICapeString,
6097 ) -> CapeResult,
6098 >,
6099 pub AddEnumeration: ::std::option::Option<
6100 unsafe extern "C" fn(
6101 me: *mut ::std::os::raw::c_void,
6102 valueName: *mut ICapeString,
6103 value: CapeEnumeration,
6104 ) -> CapeResult,
6105 >,
6106 pub AddValue: ::std::option::Option<
6107 unsafe extern "C" fn(
6108 me: *mut ::std::os::raw::c_void,
6109 valueName: *mut ICapeString,
6110 value: *mut ICapeValue,
6111 ) -> CapeResult,
6112 >,
6113 pub AddArrayReal: ::std::option::Option<
6114 unsafe extern "C" fn(
6115 me: *mut ::std::os::raw::c_void,
6116 valueName: *mut ICapeString,
6117 value: *mut ICapeArrayReal,
6118 ) -> CapeResult,
6119 >,
6120 pub AddArrayInteger: ::std::option::Option<
6121 unsafe extern "C" fn(
6122 me: *mut ::std::os::raw::c_void,
6123 valueName: *mut ICapeString,
6124 value: *mut ICapeArrayInteger,
6125 ) -> CapeResult,
6126 >,
6127 pub AddArrayBoolean: ::std::option::Option<
6128 unsafe extern "C" fn(
6129 me: *mut ::std::os::raw::c_void,
6130 valueName: *mut ICapeString,
6131 value: *mut ICapeArrayBoolean,
6132 ) -> CapeResult,
6133 >,
6134 pub AddArrayString: ::std::option::Option<
6135 unsafe extern "C" fn(
6136 me: *mut ::std::os::raw::c_void,
6137 valueName: *mut ICapeString,
6138 value: *mut ICapeArrayString,
6139 ) -> CapeResult,
6140 >,
6141 pub AddArrayEnumeration: ::std::option::Option<
6142 unsafe extern "C" fn(
6143 me: *mut ::std::os::raw::c_void,
6144 valueName: *mut ICapeString,
6145 value: *mut ICapeArrayEnumeration,
6146 ) -> CapeResult,
6147 >,
6148 pub AddArrayValue: ::std::option::Option<
6149 unsafe extern "C" fn(
6150 me: *mut ::std::os::raw::c_void,
6151 valueName: *mut ICapeString,
6152 value: *mut ICapeArrayValue,
6153 ) -> CapeResult,
6154 >,
6155 pub AddArrayByte: ::std::option::Option<
6156 unsafe extern "C" fn(
6157 me: *mut ::std::os::raw::c_void,
6158 valueName: *mut ICapeString,
6159 value: *mut ICapeArrayByte,
6160 ) -> CapeResult,
6161 >,
6162 pub AddNode: ::std::option::Option<
6163 unsafe extern "C" fn(
6164 me: *mut ::std::os::raw::c_void,
6165 nodeName: *mut ICapeString,
6166 value: *mut *mut _CAPEOPEN_1_2_ICapePersistWriter,
6167 ) -> CapeResult,
6168 >,
6169}
6170#[allow(clippy::unnecessary_operation, clippy::identity_op)]
6171const _: () = {
6172 ["Size of CAPEOPEN_1_2_ICapePersistWriter_VTable"]
6173 [::std::mem::size_of::<CAPEOPEN_1_2_ICapePersistWriter_VTable>() - 144usize];
6174 ["Alignment of CAPEOPEN_1_2_ICapePersistWriter_VTable"]
6175 [::std::mem::align_of::<CAPEOPEN_1_2_ICapePersistWriter_VTable>() - 8usize];
6176 ["Offset of field: CAPEOPEN_1_2_ICapePersistWriter_VTable::base"]
6177 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapePersistWriter_VTable, base) - 0usize];
6178 ["Offset of field: CAPEOPEN_1_2_ICapePersistWriter_VTable::AddReal"]
6179 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapePersistWriter_VTable, AddReal) - 32usize];
6180 ["Offset of field: CAPEOPEN_1_2_ICapePersistWriter_VTable::AddInteger"]
6181 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapePersistWriter_VTable, AddInteger) - 40usize];
6182 ["Offset of field: CAPEOPEN_1_2_ICapePersistWriter_VTable::AddBoolean"]
6183 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapePersistWriter_VTable, AddBoolean) - 48usize];
6184 ["Offset of field: CAPEOPEN_1_2_ICapePersistWriter_VTable::AddString"]
6185 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapePersistWriter_VTable, AddString) - 56usize];
6186 ["Offset of field: CAPEOPEN_1_2_ICapePersistWriter_VTable::AddEnumeration"]
6187 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapePersistWriter_VTable, AddEnumeration) - 64usize];
6188 ["Offset of field: CAPEOPEN_1_2_ICapePersistWriter_VTable::AddValue"]
6189 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapePersistWriter_VTable, AddValue) - 72usize];
6190 ["Offset of field: CAPEOPEN_1_2_ICapePersistWriter_VTable::AddArrayReal"]
6191 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapePersistWriter_VTable, AddArrayReal) - 80usize];
6192 ["Offset of field: CAPEOPEN_1_2_ICapePersistWriter_VTable::AddArrayInteger"]
6193 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapePersistWriter_VTable, AddArrayInteger) - 88usize];
6194 ["Offset of field: CAPEOPEN_1_2_ICapePersistWriter_VTable::AddArrayBoolean"]
6195 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapePersistWriter_VTable, AddArrayBoolean) - 96usize];
6196 ["Offset of field: CAPEOPEN_1_2_ICapePersistWriter_VTable::AddArrayString"]
6197 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapePersistWriter_VTable, AddArrayString) - 104usize];
6198 ["Offset of field: CAPEOPEN_1_2_ICapePersistWriter_VTable::AddArrayEnumeration"][::std::mem::offset_of!(
6199 CAPEOPEN_1_2_ICapePersistWriter_VTable,
6200 AddArrayEnumeration
6201 ) - 112usize];
6202 ["Offset of field: CAPEOPEN_1_2_ICapePersistWriter_VTable::AddArrayValue"]
6203 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapePersistWriter_VTable, AddArrayValue) - 120usize];
6204 ["Offset of field: CAPEOPEN_1_2_ICapePersistWriter_VTable::AddArrayByte"]
6205 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapePersistWriter_VTable, AddArrayByte) - 128usize];
6206 ["Offset of field: CAPEOPEN_1_2_ICapePersistWriter_VTable::AddNode"]
6207 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapePersistWriter_VTable, AddNode) - 136usize];
6208};
6209#[repr(C)]
6210#[derive(Debug, Copy, Clone)]
6211pub struct _CAPEOPEN_1_2_ICapePersistWriter {
6212 pub me: *mut ::std::os::raw::c_void,
6213 pub vTbl: *mut CAPEOPEN_1_2_ICapePersistWriter_VTable,
6214}
6215#[allow(clippy::unnecessary_operation, clippy::identity_op)]
6216const _: () = {
6217 ["Size of _CAPEOPEN_1_2_ICapePersistWriter"]
6218 [::std::mem::size_of::<_CAPEOPEN_1_2_ICapePersistWriter>() - 16usize];
6219 ["Alignment of _CAPEOPEN_1_2_ICapePersistWriter"]
6220 [::std::mem::align_of::<_CAPEOPEN_1_2_ICapePersistWriter>() - 8usize];
6221 ["Offset of field: _CAPEOPEN_1_2_ICapePersistWriter::me"]
6222 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapePersistWriter, me) - 0usize];
6223 ["Offset of field: _CAPEOPEN_1_2_ICapePersistWriter::vTbl"]
6224 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapePersistWriter, vTbl) - 8usize];
6225};
6226pub type CAPEOPEN_1_2_ICapePersistWriter = _CAPEOPEN_1_2_ICapePersistWriter;
6227#[repr(C)]
6228#[derive(Debug, Copy, Clone)]
6229pub struct CAPEOPEN_1_2_ICapePersistReader_VTable {
6230 pub base: ICapeInterface_VTable,
6231 pub getValueNames: ::std::option::Option<
6232 unsafe extern "C" fn(
6233 me: *mut ::std::os::raw::c_void,
6234 valueNames: *mut ICapeArrayString,
6235 ) -> CapeResult,
6236 >,
6237 pub GetValueType: ::std::option::Option<
6238 unsafe extern "C" fn(
6239 me: *mut ::std::os::raw::c_void,
6240 valueName: *mut ICapeString,
6241 valueType: *mut CAPEOPEN_1_2_CapePersistedDataType,
6242 ) -> CapeResult,
6243 >,
6244 pub GetReal: ::std::option::Option<
6245 unsafe extern "C" fn(
6246 me: *mut ::std::os::raw::c_void,
6247 valueName: *mut ICapeString,
6248 value: *mut CapeReal,
6249 ) -> CapeResult,
6250 >,
6251 pub GetInteger: ::std::option::Option<
6252 unsafe extern "C" fn(
6253 me: *mut ::std::os::raw::c_void,
6254 valueName: *mut ICapeString,
6255 value: *mut CapeInteger,
6256 ) -> CapeResult,
6257 >,
6258 pub GetBoolean: ::std::option::Option<
6259 unsafe extern "C" fn(
6260 me: *mut ::std::os::raw::c_void,
6261 valueName: *mut ICapeString,
6262 value: *mut CapeBoolean,
6263 ) -> CapeResult,
6264 >,
6265 pub GetString: ::std::option::Option<
6266 unsafe extern "C" fn(
6267 me: *mut ::std::os::raw::c_void,
6268 valueName: *mut ICapeString,
6269 value: *mut ICapeString,
6270 ) -> CapeResult,
6271 >,
6272 pub GetEnumeration: ::std::option::Option<
6273 unsafe extern "C" fn(
6274 me: *mut ::std::os::raw::c_void,
6275 valueName: *mut ICapeString,
6276 value: *mut CapeEnumeration,
6277 ) -> CapeResult,
6278 >,
6279 pub GetValue: ::std::option::Option<
6280 unsafe extern "C" fn(
6281 me: *mut ::std::os::raw::c_void,
6282 valueName: *mut ICapeString,
6283 value: *mut ICapeValue,
6284 ) -> CapeResult,
6285 >,
6286 pub GetArrayReal: ::std::option::Option<
6287 unsafe extern "C" fn(
6288 me: *mut ::std::os::raw::c_void,
6289 valueName: *mut ICapeString,
6290 value: *mut ICapeArrayReal,
6291 ) -> CapeResult,
6292 >,
6293 pub GetArrayInteger: ::std::option::Option<
6294 unsafe extern "C" fn(
6295 me: *mut ::std::os::raw::c_void,
6296 valueName: *mut ICapeString,
6297 value: *mut ICapeArrayInteger,
6298 ) -> CapeResult,
6299 >,
6300 pub GetArrayBoolean: ::std::option::Option<
6301 unsafe extern "C" fn(
6302 me: *mut ::std::os::raw::c_void,
6303 valueName: *mut ICapeString,
6304 value: *mut ICapeArrayBoolean,
6305 ) -> CapeResult,
6306 >,
6307 pub GetArrayString: ::std::option::Option<
6308 unsafe extern "C" fn(
6309 me: *mut ::std::os::raw::c_void,
6310 valueName: *mut ICapeString,
6311 value: *mut ICapeArrayString,
6312 ) -> CapeResult,
6313 >,
6314 pub GetArrayEnumeration: ::std::option::Option<
6315 unsafe extern "C" fn(
6316 me: *mut ::std::os::raw::c_void,
6317 valueName: *mut ICapeString,
6318 value: *mut ICapeArrayEnumeration,
6319 ) -> CapeResult,
6320 >,
6321 pub GetArrayValue: ::std::option::Option<
6322 unsafe extern "C" fn(
6323 me: *mut ::std::os::raw::c_void,
6324 valueName: *mut ICapeString,
6325 value: *mut ICapeArrayValue,
6326 ) -> CapeResult,
6327 >,
6328 pub GetArrayByte: ::std::option::Option<
6329 unsafe extern "C" fn(
6330 me: *mut ::std::os::raw::c_void,
6331 valueName: *mut ICapeString,
6332 value: *mut ICapeArrayByte,
6333 ) -> CapeResult,
6334 >,
6335 pub getNodeNames: ::std::option::Option<
6336 unsafe extern "C" fn(
6337 me: *mut ::std::os::raw::c_void,
6338 nodeNames: *mut ICapeArrayString,
6339 ) -> CapeResult,
6340 >,
6341 pub GetNode: ::std::option::Option<
6342 unsafe extern "C" fn(
6343 me: *mut ::std::os::raw::c_void,
6344 nodeName: *mut ICapeString,
6345 value: *mut *mut _CAPEOPEN_1_2_ICapePersistReader,
6346 ) -> CapeResult,
6347 >,
6348}
6349#[allow(clippy::unnecessary_operation, clippy::identity_op)]
6350const _: () = {
6351 ["Size of CAPEOPEN_1_2_ICapePersistReader_VTable"]
6352 [::std::mem::size_of::<CAPEOPEN_1_2_ICapePersistReader_VTable>() - 168usize];
6353 ["Alignment of CAPEOPEN_1_2_ICapePersistReader_VTable"]
6354 [::std::mem::align_of::<CAPEOPEN_1_2_ICapePersistReader_VTable>() - 8usize];
6355 ["Offset of field: CAPEOPEN_1_2_ICapePersistReader_VTable::base"]
6356 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapePersistReader_VTable, base) - 0usize];
6357 ["Offset of field: CAPEOPEN_1_2_ICapePersistReader_VTable::getValueNames"]
6358 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapePersistReader_VTable, getValueNames) - 32usize];
6359 ["Offset of field: CAPEOPEN_1_2_ICapePersistReader_VTable::GetValueType"]
6360 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapePersistReader_VTable, GetValueType) - 40usize];
6361 ["Offset of field: CAPEOPEN_1_2_ICapePersistReader_VTable::GetReal"]
6362 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapePersistReader_VTable, GetReal) - 48usize];
6363 ["Offset of field: CAPEOPEN_1_2_ICapePersistReader_VTable::GetInteger"]
6364 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapePersistReader_VTable, GetInteger) - 56usize];
6365 ["Offset of field: CAPEOPEN_1_2_ICapePersistReader_VTable::GetBoolean"]
6366 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapePersistReader_VTable, GetBoolean) - 64usize];
6367 ["Offset of field: CAPEOPEN_1_2_ICapePersistReader_VTable::GetString"]
6368 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapePersistReader_VTable, GetString) - 72usize];
6369 ["Offset of field: CAPEOPEN_1_2_ICapePersistReader_VTable::GetEnumeration"]
6370 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapePersistReader_VTable, GetEnumeration) - 80usize];
6371 ["Offset of field: CAPEOPEN_1_2_ICapePersistReader_VTable::GetValue"]
6372 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapePersistReader_VTable, GetValue) - 88usize];
6373 ["Offset of field: CAPEOPEN_1_2_ICapePersistReader_VTable::GetArrayReal"]
6374 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapePersistReader_VTable, GetArrayReal) - 96usize];
6375 ["Offset of field: CAPEOPEN_1_2_ICapePersistReader_VTable::GetArrayInteger"][::std::mem::offset_of!(
6376 CAPEOPEN_1_2_ICapePersistReader_VTable,
6377 GetArrayInteger
6378 ) - 104usize];
6379 ["Offset of field: CAPEOPEN_1_2_ICapePersistReader_VTable::GetArrayBoolean"][::std::mem::offset_of!(
6380 CAPEOPEN_1_2_ICapePersistReader_VTable,
6381 GetArrayBoolean
6382 ) - 112usize];
6383 ["Offset of field: CAPEOPEN_1_2_ICapePersistReader_VTable::GetArrayString"]
6384 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapePersistReader_VTable, GetArrayString) - 120usize];
6385 ["Offset of field: CAPEOPEN_1_2_ICapePersistReader_VTable::GetArrayEnumeration"][::std::mem::offset_of!(
6386 CAPEOPEN_1_2_ICapePersistReader_VTable,
6387 GetArrayEnumeration
6388 ) - 128usize];
6389 ["Offset of field: CAPEOPEN_1_2_ICapePersistReader_VTable::GetArrayValue"]
6390 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapePersistReader_VTable, GetArrayValue) - 136usize];
6391 ["Offset of field: CAPEOPEN_1_2_ICapePersistReader_VTable::GetArrayByte"]
6392 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapePersistReader_VTable, GetArrayByte) - 144usize];
6393 ["Offset of field: CAPEOPEN_1_2_ICapePersistReader_VTable::getNodeNames"]
6394 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapePersistReader_VTable, getNodeNames) - 152usize];
6395 ["Offset of field: CAPEOPEN_1_2_ICapePersistReader_VTable::GetNode"]
6396 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapePersistReader_VTable, GetNode) - 160usize];
6397};
6398#[repr(C)]
6399#[derive(Debug, Copy, Clone)]
6400pub struct _CAPEOPEN_1_2_ICapePersistReader {
6401 pub me: *mut ::std::os::raw::c_void,
6402 pub vTbl: *mut CAPEOPEN_1_2_ICapePersistReader_VTable,
6403}
6404#[allow(clippy::unnecessary_operation, clippy::identity_op)]
6405const _: () = {
6406 ["Size of _CAPEOPEN_1_2_ICapePersistReader"]
6407 [::std::mem::size_of::<_CAPEOPEN_1_2_ICapePersistReader>() - 16usize];
6408 ["Alignment of _CAPEOPEN_1_2_ICapePersistReader"]
6409 [::std::mem::align_of::<_CAPEOPEN_1_2_ICapePersistReader>() - 8usize];
6410 ["Offset of field: _CAPEOPEN_1_2_ICapePersistReader::me"]
6411 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapePersistReader, me) - 0usize];
6412 ["Offset of field: _CAPEOPEN_1_2_ICapePersistReader::vTbl"]
6413 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapePersistReader, vTbl) - 8usize];
6414};
6415pub type CAPEOPEN_1_2_ICapePersistReader = _CAPEOPEN_1_2_ICapePersistReader;
6416#[repr(C)]
6417#[derive(Debug, Copy, Clone)]
6418pub struct CAPEOPEN_1_2_ICapePersist_VTable {
6419 pub base: ICapeInterface_VTable,
6420 pub Save: ::std::option::Option<
6421 unsafe extern "C" fn(
6422 me: *mut ::std::os::raw::c_void,
6423 writer: *mut _CAPEOPEN_1_2_ICapePersistWriter,
6424 clearDirty: CapeBoolean,
6425 ) -> CapeResult,
6426 >,
6427 pub Load: ::std::option::Option<
6428 unsafe extern "C" fn(
6429 me: *mut ::std::os::raw::c_void,
6430 reader: *mut _CAPEOPEN_1_2_ICapePersistReader,
6431 ) -> CapeResult,
6432 >,
6433 pub getIsDirty: ::std::option::Option<
6434 unsafe extern "C" fn(
6435 me: *mut ::std::os::raw::c_void,
6436 dirty: *mut CapeBoolean,
6437 ) -> CapeResult,
6438 >,
6439}
6440#[allow(clippy::unnecessary_operation, clippy::identity_op)]
6441const _: () = {
6442 ["Size of CAPEOPEN_1_2_ICapePersist_VTable"]
6443 [::std::mem::size_of::<CAPEOPEN_1_2_ICapePersist_VTable>() - 56usize];
6444 ["Alignment of CAPEOPEN_1_2_ICapePersist_VTable"]
6445 [::std::mem::align_of::<CAPEOPEN_1_2_ICapePersist_VTable>() - 8usize];
6446 ["Offset of field: CAPEOPEN_1_2_ICapePersist_VTable::base"]
6447 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapePersist_VTable, base) - 0usize];
6448 ["Offset of field: CAPEOPEN_1_2_ICapePersist_VTable::Save"]
6449 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapePersist_VTable, Save) - 32usize];
6450 ["Offset of field: CAPEOPEN_1_2_ICapePersist_VTable::Load"]
6451 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapePersist_VTable, Load) - 40usize];
6452 ["Offset of field: CAPEOPEN_1_2_ICapePersist_VTable::getIsDirty"]
6453 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapePersist_VTable, getIsDirty) - 48usize];
6454};
6455#[repr(C)]
6456#[derive(Debug, Copy, Clone)]
6457pub struct _CAPEOPEN_1_2_ICapePersist {
6458 pub me: *mut ::std::os::raw::c_void,
6459 pub vTbl: *mut CAPEOPEN_1_2_ICapePersist_VTable,
6460}
6461#[allow(clippy::unnecessary_operation, clippy::identity_op)]
6462const _: () = {
6463 ["Size of _CAPEOPEN_1_2_ICapePersist"]
6464 [::std::mem::size_of::<_CAPEOPEN_1_2_ICapePersist>() - 16usize];
6465 ["Alignment of _CAPEOPEN_1_2_ICapePersist"]
6466 [::std::mem::align_of::<_CAPEOPEN_1_2_ICapePersist>() - 8usize];
6467 ["Offset of field: _CAPEOPEN_1_2_ICapePersist::me"]
6468 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapePersist, me) - 0usize];
6469 ["Offset of field: _CAPEOPEN_1_2_ICapePersist::vTbl"]
6470 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapePersist, vTbl) - 8usize];
6471};
6472pub type CAPEOPEN_1_2_ICapePersist = _CAPEOPEN_1_2_ICapePersist;
6473#[repr(C)]
6474#[derive(Debug, Copy, Clone)]
6475pub struct CAPEOPEN_1_2_ICapeReport_VTable {
6476 pub base: ICapeInterface_VTable,
6477 pub getReportNames: ::std::option::Option<
6478 unsafe extern "C" fn(
6479 me: *mut ::std::os::raw::c_void,
6480 names: *mut ICapeArrayString,
6481 ) -> CapeResult,
6482 >,
6483 pub ReportTypes: ::std::option::Option<
6484 unsafe extern "C" fn(
6485 me: *mut ::std::os::raw::c_void,
6486 name: *mut ICapeString,
6487 types: *mut ICapeArrayString,
6488 ) -> CapeResult,
6489 >,
6490 pub ReportLocales: ::std::option::Option<
6491 unsafe extern "C" fn(
6492 me: *mut ::std::os::raw::c_void,
6493 name: *mut ICapeString,
6494 type_: *mut ICapeString,
6495 locales: *mut ICapeArrayString,
6496 ) -> CapeResult,
6497 >,
6498 pub CheckReportSpec: ::std::option::Option<
6499 unsafe extern "C" fn(
6500 me: *mut ::std::os::raw::c_void,
6501 name: *mut ICapeString,
6502 type_: *mut ICapeString,
6503 locale: *mut ICapeString,
6504 reportAvailable: *mut CapeBoolean,
6505 ) -> CapeResult,
6506 >,
6507 pub GenerateReport: ::std::option::Option<
6508 unsafe extern "C" fn(
6509 me: *mut ::std::os::raw::c_void,
6510 name: *mut ICapeString,
6511 type_: *mut ICapeString,
6512 locale: *mut ICapeString,
6513 reportContent: *mut ICapeString,
6514 ) -> CapeResult,
6515 >,
6516 pub GenerateReportFile: ::std::option::Option<
6517 unsafe extern "C" fn(
6518 me: *mut ::std::os::raw::c_void,
6519 name: *mut ICapeString,
6520 type_: *mut ICapeString,
6521 locale: *mut ICapeString,
6522 fileName: *mut ICapeString,
6523 ) -> CapeResult,
6524 >,
6525}
6526#[allow(clippy::unnecessary_operation, clippy::identity_op)]
6527const _: () = {
6528 ["Size of CAPEOPEN_1_2_ICapeReport_VTable"]
6529 [::std::mem::size_of::<CAPEOPEN_1_2_ICapeReport_VTable>() - 80usize];
6530 ["Alignment of CAPEOPEN_1_2_ICapeReport_VTable"]
6531 [::std::mem::align_of::<CAPEOPEN_1_2_ICapeReport_VTable>() - 8usize];
6532 ["Offset of field: CAPEOPEN_1_2_ICapeReport_VTable::base"]
6533 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeReport_VTable, base) - 0usize];
6534 ["Offset of field: CAPEOPEN_1_2_ICapeReport_VTable::getReportNames"]
6535 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeReport_VTable, getReportNames) - 32usize];
6536 ["Offset of field: CAPEOPEN_1_2_ICapeReport_VTable::ReportTypes"]
6537 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeReport_VTable, ReportTypes) - 40usize];
6538 ["Offset of field: CAPEOPEN_1_2_ICapeReport_VTable::ReportLocales"]
6539 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeReport_VTable, ReportLocales) - 48usize];
6540 ["Offset of field: CAPEOPEN_1_2_ICapeReport_VTable::CheckReportSpec"]
6541 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeReport_VTable, CheckReportSpec) - 56usize];
6542 ["Offset of field: CAPEOPEN_1_2_ICapeReport_VTable::GenerateReport"]
6543 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeReport_VTable, GenerateReport) - 64usize];
6544 ["Offset of field: CAPEOPEN_1_2_ICapeReport_VTable::GenerateReportFile"]
6545 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeReport_VTable, GenerateReportFile) - 72usize];
6546};
6547#[repr(C)]
6548#[derive(Debug, Copy, Clone)]
6549pub struct _CAPEOPEN_1_2_ICapeReport {
6550 pub me: *mut ::std::os::raw::c_void,
6551 pub vTbl: *mut CAPEOPEN_1_2_ICapeReport_VTable,
6552}
6553#[allow(clippy::unnecessary_operation, clippy::identity_op)]
6554const _: () = {
6555 ["Size of _CAPEOPEN_1_2_ICapeReport"]
6556 [::std::mem::size_of::<_CAPEOPEN_1_2_ICapeReport>() - 16usize];
6557 ["Alignment of _CAPEOPEN_1_2_ICapeReport"]
6558 [::std::mem::align_of::<_CAPEOPEN_1_2_ICapeReport>() - 8usize];
6559 ["Offset of field: _CAPEOPEN_1_2_ICapeReport::me"]
6560 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapeReport, me) - 0usize];
6561 ["Offset of field: _CAPEOPEN_1_2_ICapeReport::vTbl"]
6562 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapeReport, vTbl) - 8usize];
6563};
6564pub type CAPEOPEN_1_2_ICapeReport = _CAPEOPEN_1_2_ICapeReport;
6565#[repr(C)]
6566#[derive(Debug, Copy, Clone)]
6567pub struct CAPEOPEN_1_2_ICapeFlowsheetMonitoringComponent_VTable {
6568 pub base: ICapeInterface_VTable,
6569 pub Monitor:
6570 ::std::option::Option<unsafe extern "C" fn(me: *mut ::std::os::raw::c_void) -> CapeResult>,
6571 pub Validate: ::std::option::Option<
6572 unsafe extern "C" fn(
6573 me: *mut ::std::os::raw::c_void,
6574 message: *mut ICapeString,
6575 isValid: *mut CapeBoolean,
6576 ) -> CapeResult,
6577 >,
6578 pub getValStatus: ::std::option::Option<
6579 unsafe extern "C" fn(
6580 me: *mut ::std::os::raw::c_void,
6581 validationStatus: *mut CAPEOPEN_1_2_CapeValidationStatus,
6582 ) -> CapeResult,
6583 >,
6584}
6585#[allow(clippy::unnecessary_operation, clippy::identity_op)]
6586const _: () = {
6587 ["Size of CAPEOPEN_1_2_ICapeFlowsheetMonitoringComponent_VTable"]
6588 [::std::mem::size_of::<CAPEOPEN_1_2_ICapeFlowsheetMonitoringComponent_VTable>() - 56usize];
6589 ["Alignment of CAPEOPEN_1_2_ICapeFlowsheetMonitoringComponent_VTable"]
6590 [::std::mem::align_of::<CAPEOPEN_1_2_ICapeFlowsheetMonitoringComponent_VTable>() - 8usize];
6591 ["Offset of field: CAPEOPEN_1_2_ICapeFlowsheetMonitoringComponent_VTable::base"][::std::mem::offset_of!(
6592 CAPEOPEN_1_2_ICapeFlowsheetMonitoringComponent_VTable,
6593 base
6594 ) - 0usize];
6595 ["Offset of field: CAPEOPEN_1_2_ICapeFlowsheetMonitoringComponent_VTable::Monitor"][::std::mem::offset_of!(
6596 CAPEOPEN_1_2_ICapeFlowsheetMonitoringComponent_VTable,
6597 Monitor
6598 )
6599 - 32usize];
6600 ["Offset of field: CAPEOPEN_1_2_ICapeFlowsheetMonitoringComponent_VTable::Validate"][::std::mem::offset_of!(
6601 CAPEOPEN_1_2_ICapeFlowsheetMonitoringComponent_VTable,
6602 Validate
6603 )
6604 - 40usize];
6605 ["Offset of field: CAPEOPEN_1_2_ICapeFlowsheetMonitoringComponent_VTable::getValStatus"][::std::mem::offset_of!(
6606 CAPEOPEN_1_2_ICapeFlowsheetMonitoringComponent_VTable,
6607 getValStatus
6608 )
6609 - 48usize];
6610};
6611#[repr(C)]
6612#[derive(Debug, Copy, Clone)]
6613pub struct _CAPEOPEN_1_2_ICapeFlowsheetMonitoringComponent {
6614 pub me: *mut ::std::os::raw::c_void,
6615 pub vTbl: *mut CAPEOPEN_1_2_ICapeFlowsheetMonitoringComponent_VTable,
6616}
6617#[allow(clippy::unnecessary_operation, clippy::identity_op)]
6618const _: () = {
6619 ["Size of _CAPEOPEN_1_2_ICapeFlowsheetMonitoringComponent"]
6620 [::std::mem::size_of::<_CAPEOPEN_1_2_ICapeFlowsheetMonitoringComponent>() - 16usize];
6621 ["Alignment of _CAPEOPEN_1_2_ICapeFlowsheetMonitoringComponent"]
6622 [::std::mem::align_of::<_CAPEOPEN_1_2_ICapeFlowsheetMonitoringComponent>() - 8usize];
6623 ["Offset of field: _CAPEOPEN_1_2_ICapeFlowsheetMonitoringComponent::me"]
6624 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapeFlowsheetMonitoringComponent, me) - 0usize];
6625 ["Offset of field: _CAPEOPEN_1_2_ICapeFlowsheetMonitoringComponent::vTbl"]
6626 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapeFlowsheetMonitoringComponent, vTbl) - 8usize];
6627};
6628pub type CAPEOPEN_1_2_ICapeFlowsheetMonitoringComponent =
6629 _CAPEOPEN_1_2_ICapeFlowsheetMonitoringComponent;
6630#[repr(C)]
6631#[derive(Debug, Copy, Clone)]
6632pub struct CAPEOPEN_1_2_ICapeStream_VTable {
6633 pub base: ICapeInterface_VTable,
6634 pub StreamType: ::std::option::Option<
6635 unsafe extern "C" fn(
6636 me: *mut ::std::os::raw::c_void,
6637 StreamType: *mut CAPEOPEN_1_2_CapeStreamType,
6638 ) -> CapeResult,
6639 >,
6640 pub getStreamObject: ::std::option::Option<
6641 unsafe extern "C" fn(
6642 me: *mut ::std::os::raw::c_void,
6643 streamObject: *mut *mut ICapeInterface,
6644 ) -> CapeResult,
6645 >,
6646 pub GetUpstreamPortConnection: ::std::option::Option<
6647 unsafe extern "C" fn(
6648 me: *mut ::std::os::raw::c_void,
6649 upstreamPort: *mut ICapeString,
6650 upstreamUnit: *mut ICapeString,
6651 ) -> CapeResult,
6652 >,
6653 pub GetDownstreamPortConnection: ::std::option::Option<
6654 unsafe extern "C" fn(
6655 me: *mut ::std::os::raw::c_void,
6656 downstreamPort: *mut ICapeString,
6657 downstreamUnit: *mut ICapeString,
6658 ) -> CapeResult,
6659 >,
6660}
6661#[allow(clippy::unnecessary_operation, clippy::identity_op)]
6662const _: () = {
6663 ["Size of CAPEOPEN_1_2_ICapeStream_VTable"]
6664 [::std::mem::size_of::<CAPEOPEN_1_2_ICapeStream_VTable>() - 64usize];
6665 ["Alignment of CAPEOPEN_1_2_ICapeStream_VTable"]
6666 [::std::mem::align_of::<CAPEOPEN_1_2_ICapeStream_VTable>() - 8usize];
6667 ["Offset of field: CAPEOPEN_1_2_ICapeStream_VTable::base"]
6668 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeStream_VTable, base) - 0usize];
6669 ["Offset of field: CAPEOPEN_1_2_ICapeStream_VTable::StreamType"]
6670 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeStream_VTable, StreamType) - 32usize];
6671 ["Offset of field: CAPEOPEN_1_2_ICapeStream_VTable::getStreamObject"]
6672 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeStream_VTable, getStreamObject) - 40usize];
6673 ["Offset of field: CAPEOPEN_1_2_ICapeStream_VTable::GetUpstreamPortConnection"][::std::mem::offset_of!(
6674 CAPEOPEN_1_2_ICapeStream_VTable,
6675 GetUpstreamPortConnection
6676 ) - 48usize];
6677 ["Offset of field: CAPEOPEN_1_2_ICapeStream_VTable::GetDownstreamPortConnection"][::std::mem::offset_of!(
6678 CAPEOPEN_1_2_ICapeStream_VTable,
6679 GetDownstreamPortConnection
6680 ) - 56usize];
6681};
6682#[repr(C)]
6683#[derive(Debug, Copy, Clone)]
6684pub struct _CAPEOPEN_1_2_ICapeStream {
6685 pub me: *mut ::std::os::raw::c_void,
6686 pub vTbl: *mut CAPEOPEN_1_2_ICapeStream_VTable,
6687}
6688#[allow(clippy::unnecessary_operation, clippy::identity_op)]
6689const _: () = {
6690 ["Size of _CAPEOPEN_1_2_ICapeStream"]
6691 [::std::mem::size_of::<_CAPEOPEN_1_2_ICapeStream>() - 16usize];
6692 ["Alignment of _CAPEOPEN_1_2_ICapeStream"]
6693 [::std::mem::align_of::<_CAPEOPEN_1_2_ICapeStream>() - 8usize];
6694 ["Offset of field: _CAPEOPEN_1_2_ICapeStream::me"]
6695 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapeStream, me) - 0usize];
6696 ["Offset of field: _CAPEOPEN_1_2_ICapeStream::vTbl"]
6697 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapeStream, vTbl) - 8usize];
6698};
6699pub type CAPEOPEN_1_2_ICapeStream = _CAPEOPEN_1_2_ICapeStream;
6700#[repr(C)]
6701#[derive(Debug, Copy, Clone)]
6702pub struct CAPEOPEN_1_2_ICapeFlowsheetMonitoringEventSink_VTable {
6703 pub base: ICapeInterface_VTable,
6704 pub UnitOperationAdded: ::std::option::Option<
6705 unsafe extern "C" fn(
6706 me: *mut ::std::os::raw::c_void,
6707 unit: *mut _CAPEOPEN_1_2_ICapeUnit,
6708 ) -> CapeResult,
6709 >,
6710 pub UnitOperationRemoved: ::std::option::Option<
6711 unsafe extern "C" fn(
6712 me: *mut ::std::os::raw::c_void,
6713 unit: *mut _CAPEOPEN_1_2_ICapeUnit,
6714 ) -> CapeResult,
6715 >,
6716 pub UnitOperationRenamed: ::std::option::Option<
6717 unsafe extern "C" fn(
6718 me: *mut ::std::os::raw::c_void,
6719 unit: *mut _CAPEOPEN_1_2_ICapeUnit,
6720 oldName: *mut ICapeString,
6721 ) -> CapeResult,
6722 >,
6723 pub StreamAdded: ::std::option::Option<
6724 unsafe extern "C" fn(
6725 me: *mut ::std::os::raw::c_void,
6726 stream: *mut _CAPEOPEN_1_2_ICapeStream,
6727 type_: CAPEOPEN_1_2_CapeStreamType,
6728 ) -> CapeResult,
6729 >,
6730 pub StreamRemoved: ::std::option::Option<
6731 unsafe extern "C" fn(
6732 me: *mut ::std::os::raw::c_void,
6733 stream: *mut _CAPEOPEN_1_2_ICapeStream,
6734 type_: CAPEOPEN_1_2_CapeStreamType,
6735 ) -> CapeResult,
6736 >,
6737 pub StreamRenamed: ::std::option::Option<
6738 unsafe extern "C" fn(
6739 me: *mut ::std::os::raw::c_void,
6740 stream: *mut _CAPEOPEN_1_2_ICapeStream,
6741 type_: CAPEOPEN_1_2_CapeStreamType,
6742 oldName: *mut ICapeString,
6743 ) -> CapeResult,
6744 >,
6745 pub ConnectionChanged: ::std::option::Option<
6746 unsafe extern "C" fn(
6747 me: *mut ::std::os::raw::c_void,
6748 stream: *mut _CAPEOPEN_1_2_ICapeStream,
6749 type_: CAPEOPEN_1_2_CapeStreamType,
6750 port: *mut _CAPEOPEN_1_2_ICapeUnitPort,
6751 unit: *mut _CAPEOPEN_1_2_ICapeUnit,
6752 ) -> CapeResult,
6753 >,
6754 pub FlowsheetSolutionStatusChanged: ::std::option::Option<
6755 unsafe extern "C" fn(
6756 me: *mut ::std::os::raw::c_void,
6757 solutionStatus: CAPEOPEN_1_2_CapeSolutionStatus,
6758 ) -> CapeResult,
6759 >,
6760 pub FlowsheetValidationStateChanged: ::std::option::Option<
6761 unsafe extern "C" fn(
6762 me: *mut ::std::os::raw::c_void,
6763 validationStatus: CAPEOPEN_1_2_CapeValidationStatus,
6764 ) -> CapeResult,
6765 >,
6766 pub NextTimeStep:
6767 ::std::option::Option<unsafe extern "C" fn(me: *mut ::std::os::raw::c_void) -> CapeResult>,
6768}
6769#[allow(clippy::unnecessary_operation, clippy::identity_op)]
6770const _: () = {
6771 ["Size of CAPEOPEN_1_2_ICapeFlowsheetMonitoringEventSink_VTable"]
6772 [::std::mem::size_of::<CAPEOPEN_1_2_ICapeFlowsheetMonitoringEventSink_VTable>() - 112usize];
6773 ["Alignment of CAPEOPEN_1_2_ICapeFlowsheetMonitoringEventSink_VTable"]
6774 [::std::mem::align_of::<CAPEOPEN_1_2_ICapeFlowsheetMonitoringEventSink_VTable>() - 8usize];
6775 ["Offset of field: CAPEOPEN_1_2_ICapeFlowsheetMonitoringEventSink_VTable::base"][::std::mem::offset_of!(
6776 CAPEOPEN_1_2_ICapeFlowsheetMonitoringEventSink_VTable,
6777 base
6778 ) - 0usize];
6779 ["Offset of field: CAPEOPEN_1_2_ICapeFlowsheetMonitoringEventSink_VTable::UnitOperationAdded"] [:: std :: mem :: offset_of ! (CAPEOPEN_1_2_ICapeFlowsheetMonitoringEventSink_VTable , UnitOperationAdded) - 32usize] ;
6780 ["Offset of field: CAPEOPEN_1_2_ICapeFlowsheetMonitoringEventSink_VTable::UnitOperationRemoved"] [:: std :: mem :: offset_of ! (CAPEOPEN_1_2_ICapeFlowsheetMonitoringEventSink_VTable , UnitOperationRemoved) - 40usize] ;
6781 ["Offset of field: CAPEOPEN_1_2_ICapeFlowsheetMonitoringEventSink_VTable::UnitOperationRenamed"] [:: std :: mem :: offset_of ! (CAPEOPEN_1_2_ICapeFlowsheetMonitoringEventSink_VTable , UnitOperationRenamed) - 48usize] ;
6782 ["Offset of field: CAPEOPEN_1_2_ICapeFlowsheetMonitoringEventSink_VTable::StreamAdded"][::std::mem::offset_of!(
6783 CAPEOPEN_1_2_ICapeFlowsheetMonitoringEventSink_VTable,
6784 StreamAdded
6785 )
6786 - 56usize];
6787 ["Offset of field: CAPEOPEN_1_2_ICapeFlowsheetMonitoringEventSink_VTable::StreamRemoved"][::std::mem::offset_of!(
6788 CAPEOPEN_1_2_ICapeFlowsheetMonitoringEventSink_VTable,
6789 StreamRemoved
6790 )
6791 - 64usize];
6792 ["Offset of field: CAPEOPEN_1_2_ICapeFlowsheetMonitoringEventSink_VTable::StreamRenamed"][::std::mem::offset_of!(
6793 CAPEOPEN_1_2_ICapeFlowsheetMonitoringEventSink_VTable,
6794 StreamRenamed
6795 )
6796 - 72usize];
6797 ["Offset of field: CAPEOPEN_1_2_ICapeFlowsheetMonitoringEventSink_VTable::ConnectionChanged"][::std::mem::offset_of!(
6798 CAPEOPEN_1_2_ICapeFlowsheetMonitoringEventSink_VTable,
6799 ConnectionChanged
6800 )
6801 - 80usize];
6802 ["Offset of field: CAPEOPEN_1_2_ICapeFlowsheetMonitoringEventSink_VTable::FlowsheetSolutionStatusChanged"] [:: std :: mem :: offset_of ! (CAPEOPEN_1_2_ICapeFlowsheetMonitoringEventSink_VTable , FlowsheetSolutionStatusChanged) - 88usize] ;
6803 ["Offset of field: CAPEOPEN_1_2_ICapeFlowsheetMonitoringEventSink_VTable::FlowsheetValidationStateChanged"] [:: std :: mem :: offset_of ! (CAPEOPEN_1_2_ICapeFlowsheetMonitoringEventSink_VTable , FlowsheetValidationStateChanged) - 96usize] ;
6804 ["Offset of field: CAPEOPEN_1_2_ICapeFlowsheetMonitoringEventSink_VTable::NextTimeStep"][::std::mem::offset_of!(
6805 CAPEOPEN_1_2_ICapeFlowsheetMonitoringEventSink_VTable,
6806 NextTimeStep
6807 )
6808 - 104usize];
6809};
6810#[repr(C)]
6811#[derive(Debug, Copy, Clone)]
6812pub struct _CAPEOPEN_1_2_ICapeFlowsheetMonitoringEventSink {
6813 pub me: *mut ::std::os::raw::c_void,
6814 pub vTbl: *mut CAPEOPEN_1_2_ICapeFlowsheetMonitoringEventSink_VTable,
6815}
6816#[allow(clippy::unnecessary_operation, clippy::identity_op)]
6817const _: () = {
6818 ["Size of _CAPEOPEN_1_2_ICapeFlowsheetMonitoringEventSink"]
6819 [::std::mem::size_of::<_CAPEOPEN_1_2_ICapeFlowsheetMonitoringEventSink>() - 16usize];
6820 ["Alignment of _CAPEOPEN_1_2_ICapeFlowsheetMonitoringEventSink"]
6821 [::std::mem::align_of::<_CAPEOPEN_1_2_ICapeFlowsheetMonitoringEventSink>() - 8usize];
6822 ["Offset of field: _CAPEOPEN_1_2_ICapeFlowsheetMonitoringEventSink::me"]
6823 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapeFlowsheetMonitoringEventSink, me) - 0usize];
6824 ["Offset of field: _CAPEOPEN_1_2_ICapeFlowsheetMonitoringEventSink::vTbl"]
6825 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapeFlowsheetMonitoringEventSink, vTbl) - 8usize];
6826};
6827pub type CAPEOPEN_1_2_ICapeFlowsheetMonitoringEventSink =
6828 _CAPEOPEN_1_2_ICapeFlowsheetMonitoringEventSink;
6829#[repr(C)]
6830#[derive(Debug, Copy, Clone)]
6831pub struct CAPEOPEN_1_2_ICapeFlowsheetMonitoring_VTable {
6832 pub base: ICapeInterface_VTable,
6833 pub GetStreamCollection: ::std::option::Option<
6834 unsafe extern "C" fn(
6835 me: *mut ::std::os::raw::c_void,
6836 type_: CAPEOPEN_1_2_CapeStreamType,
6837 streamCollection: *mut *mut _CAPEOPEN_1_2_ICapeCollection,
6838 ) -> CapeResult,
6839 >,
6840 pub GetUnitOperationCollection: ::std::option::Option<
6841 unsafe extern "C" fn(
6842 me: *mut ::std::os::raw::c_void,
6843 UnitOperationCollection: *mut *mut _CAPEOPEN_1_2_ICapeCollection,
6844 ) -> CapeResult,
6845 >,
6846 pub getSolutionStatus: ::std::option::Option<
6847 unsafe extern "C" fn(
6848 me: *mut ::std::os::raw::c_void,
6849 solutionStatus: *mut CAPEOPEN_1_2_CapeSolutionStatus,
6850 ) -> CapeResult,
6851 >,
6852 pub getValStatus: ::std::option::Option<
6853 unsafe extern "C" fn(
6854 me: *mut ::std::os::raw::c_void,
6855 validationStatus: *mut CAPEOPEN_1_2_CapeValidationStatus,
6856 ) -> CapeResult,
6857 >,
6858 pub RegisterForEvents: ::std::option::Option<
6859 unsafe extern "C" fn(
6860 me: *mut ::std::os::raw::c_void,
6861 component: *mut ICapeInterface,
6862 events: *mut ICapeArrayEnumeration,
6863 ) -> CapeResult,
6864 >,
6865 pub getSupportedEvents: ::std::option::Option<
6866 unsafe extern "C" fn(
6867 me: *mut ::std::os::raw::c_void,
6868 SupportedEvents: *mut ICapeArrayEnumeration,
6869 ) -> CapeResult,
6870 >,
6871}
6872#[allow(clippy::unnecessary_operation, clippy::identity_op)]
6873const _: () = {
6874 ["Size of CAPEOPEN_1_2_ICapeFlowsheetMonitoring_VTable"]
6875 [::std::mem::size_of::<CAPEOPEN_1_2_ICapeFlowsheetMonitoring_VTable>() - 80usize];
6876 ["Alignment of CAPEOPEN_1_2_ICapeFlowsheetMonitoring_VTable"]
6877 [::std::mem::align_of::<CAPEOPEN_1_2_ICapeFlowsheetMonitoring_VTable>() - 8usize];
6878 ["Offset of field: CAPEOPEN_1_2_ICapeFlowsheetMonitoring_VTable::base"]
6879 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeFlowsheetMonitoring_VTable, base) - 0usize];
6880 ["Offset of field: CAPEOPEN_1_2_ICapeFlowsheetMonitoring_VTable::GetStreamCollection"][::std::mem::offset_of!(
6881 CAPEOPEN_1_2_ICapeFlowsheetMonitoring_VTable,
6882 GetStreamCollection
6883 )
6884 - 32usize];
6885 ["Offset of field: CAPEOPEN_1_2_ICapeFlowsheetMonitoring_VTable::GetUnitOperationCollection"][::std::mem::offset_of!(
6886 CAPEOPEN_1_2_ICapeFlowsheetMonitoring_VTable,
6887 GetUnitOperationCollection
6888 )
6889 - 40usize];
6890 ["Offset of field: CAPEOPEN_1_2_ICapeFlowsheetMonitoring_VTable::getSolutionStatus"][::std::mem::offset_of!(
6891 CAPEOPEN_1_2_ICapeFlowsheetMonitoring_VTable,
6892 getSolutionStatus
6893 )
6894 - 48usize];
6895 ["Offset of field: CAPEOPEN_1_2_ICapeFlowsheetMonitoring_VTable::getValStatus"][::std::mem::offset_of!(
6896 CAPEOPEN_1_2_ICapeFlowsheetMonitoring_VTable,
6897 getValStatus
6898 ) - 56usize];
6899 ["Offset of field: CAPEOPEN_1_2_ICapeFlowsheetMonitoring_VTable::RegisterForEvents"][::std::mem::offset_of!(
6900 CAPEOPEN_1_2_ICapeFlowsheetMonitoring_VTable,
6901 RegisterForEvents
6902 )
6903 - 64usize];
6904 ["Offset of field: CAPEOPEN_1_2_ICapeFlowsheetMonitoring_VTable::getSupportedEvents"][::std::mem::offset_of!(
6905 CAPEOPEN_1_2_ICapeFlowsheetMonitoring_VTable,
6906 getSupportedEvents
6907 )
6908 - 72usize];
6909};
6910#[repr(C)]
6911#[derive(Debug, Copy, Clone)]
6912pub struct _CAPEOPEN_1_2_ICapeFlowsheetMonitoring {
6913 pub me: *mut ::std::os::raw::c_void,
6914 pub vTbl: *mut CAPEOPEN_1_2_ICapeFlowsheetMonitoring_VTable,
6915}
6916#[allow(clippy::unnecessary_operation, clippy::identity_op)]
6917const _: () = {
6918 ["Size of _CAPEOPEN_1_2_ICapeFlowsheetMonitoring"]
6919 [::std::mem::size_of::<_CAPEOPEN_1_2_ICapeFlowsheetMonitoring>() - 16usize];
6920 ["Alignment of _CAPEOPEN_1_2_ICapeFlowsheetMonitoring"]
6921 [::std::mem::align_of::<_CAPEOPEN_1_2_ICapeFlowsheetMonitoring>() - 8usize];
6922 ["Offset of field: _CAPEOPEN_1_2_ICapeFlowsheetMonitoring::me"]
6923 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapeFlowsheetMonitoring, me) - 0usize];
6924 ["Offset of field: _CAPEOPEN_1_2_ICapeFlowsheetMonitoring::vTbl"]
6925 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapeFlowsheetMonitoring, vTbl) - 8usize];
6926};
6927pub type CAPEOPEN_1_2_ICapeFlowsheetMonitoring = _CAPEOPEN_1_2_ICapeFlowsheetMonitoring;
6928#[repr(C)]
6929#[derive(Debug, Copy, Clone)]
6930pub struct CAPEOPEN_1_2_ICapeThermoMaterialCustomData_VTable {
6931 pub base: ICapeInterface_VTable,
6932 pub GetCustomDataContainer: ::std::option::Option<
6933 unsafe extern "C" fn(
6934 me: *mut ::std::os::raw::c_void,
6935 source: *mut ICapeInterface,
6936 customDataContainer: *mut *mut ICapeInterface,
6937 ) -> CapeResult,
6938 >,
6939}
6940#[allow(clippy::unnecessary_operation, clippy::identity_op)]
6941const _: () = {
6942 ["Size of CAPEOPEN_1_2_ICapeThermoMaterialCustomData_VTable"]
6943 [::std::mem::size_of::<CAPEOPEN_1_2_ICapeThermoMaterialCustomData_VTable>() - 40usize];
6944 ["Alignment of CAPEOPEN_1_2_ICapeThermoMaterialCustomData_VTable"]
6945 [::std::mem::align_of::<CAPEOPEN_1_2_ICapeThermoMaterialCustomData_VTable>() - 8usize];
6946 ["Offset of field: CAPEOPEN_1_2_ICapeThermoMaterialCustomData_VTable::base"]
6947 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeThermoMaterialCustomData_VTable, base) - 0usize];
6948 ["Offset of field: CAPEOPEN_1_2_ICapeThermoMaterialCustomData_VTable::GetCustomDataContainer"] [:: std :: mem :: offset_of ! (CAPEOPEN_1_2_ICapeThermoMaterialCustomData_VTable , GetCustomDataContainer) - 32usize] ;
6949};
6950#[repr(C)]
6951#[derive(Debug, Copy, Clone)]
6952pub struct _CAPEOPEN_1_2_ICapeThermoMaterialCustomData {
6953 pub me: *mut ::std::os::raw::c_void,
6954 pub vTbl: *mut CAPEOPEN_1_2_ICapeThermoMaterialCustomData_VTable,
6955}
6956#[allow(clippy::unnecessary_operation, clippy::identity_op)]
6957const _: () = {
6958 ["Size of _CAPEOPEN_1_2_ICapeThermoMaterialCustomData"]
6959 [::std::mem::size_of::<_CAPEOPEN_1_2_ICapeThermoMaterialCustomData>() - 16usize];
6960 ["Alignment of _CAPEOPEN_1_2_ICapeThermoMaterialCustomData"]
6961 [::std::mem::align_of::<_CAPEOPEN_1_2_ICapeThermoMaterialCustomData>() - 8usize];
6962 ["Offset of field: _CAPEOPEN_1_2_ICapeThermoMaterialCustomData::me"]
6963 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapeThermoMaterialCustomData, me) - 0usize];
6964 ["Offset of field: _CAPEOPEN_1_2_ICapeThermoMaterialCustomData::vTbl"]
6965 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapeThermoMaterialCustomData, vTbl) - 8usize];
6966};
6967pub type CAPEOPEN_1_2_ICapeThermoMaterialCustomData = _CAPEOPEN_1_2_ICapeThermoMaterialCustomData;
6968#[repr(C)]
6969#[derive(Debug, Copy, Clone)]
6970pub struct CAPEOPEN_1_2_ICapeCustomDataSource_VTable {
6971 pub base: ICapeInterface_VTable,
6972 pub CreateCustomDataContainer: ::std::option::Option<
6973 unsafe extern "C" fn(
6974 me: *mut ::std::os::raw::c_void,
6975 customDataContainer: *mut *mut ICapeInterface,
6976 ) -> CapeResult,
6977 >,
6978 pub CopyCustomData: ::std::option::Option<
6979 unsafe extern "C" fn(
6980 me: *mut ::std::os::raw::c_void,
6981 source: *mut ICapeInterface,
6982 target: *mut ICapeInterface,
6983 ) -> CapeResult,
6984 >,
6985 pub ThermodynamicConfigurationChanged: ::std::option::Option<
6986 unsafe extern "C" fn(
6987 me: *mut ::std::os::raw::c_void,
6988 container: *mut ICapeInterface,
6989 ) -> CapeResult,
6990 >,
6991}
6992#[allow(clippy::unnecessary_operation, clippy::identity_op)]
6993const _: () = {
6994 ["Size of CAPEOPEN_1_2_ICapeCustomDataSource_VTable"]
6995 [::std::mem::size_of::<CAPEOPEN_1_2_ICapeCustomDataSource_VTable>() - 56usize];
6996 ["Alignment of CAPEOPEN_1_2_ICapeCustomDataSource_VTable"]
6997 [::std::mem::align_of::<CAPEOPEN_1_2_ICapeCustomDataSource_VTable>() - 8usize];
6998 ["Offset of field: CAPEOPEN_1_2_ICapeCustomDataSource_VTable::base"]
6999 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeCustomDataSource_VTable, base) - 0usize];
7000 ["Offset of field: CAPEOPEN_1_2_ICapeCustomDataSource_VTable::CreateCustomDataContainer"][::std::mem::offset_of!(
7001 CAPEOPEN_1_2_ICapeCustomDataSource_VTable,
7002 CreateCustomDataContainer
7003 )
7004 - 32usize];
7005 ["Offset of field: CAPEOPEN_1_2_ICapeCustomDataSource_VTable::CopyCustomData"][::std::mem::offset_of!(
7006 CAPEOPEN_1_2_ICapeCustomDataSource_VTable,
7007 CopyCustomData
7008 ) - 40usize];
7009 ["Offset of field: CAPEOPEN_1_2_ICapeCustomDataSource_VTable::ThermodynamicConfigurationChanged"] [:: std :: mem :: offset_of ! (CAPEOPEN_1_2_ICapeCustomDataSource_VTable , ThermodynamicConfigurationChanged) - 48usize] ;
7010};
7011#[repr(C)]
7012#[derive(Debug, Copy, Clone)]
7013pub struct _CAPEOPEN_1_2_ICapeCustomDataSource {
7014 pub me: *mut ::std::os::raw::c_void,
7015 pub vTbl: *mut CAPEOPEN_1_2_ICapeCustomDataSource_VTable,
7016}
7017#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7018const _: () = {
7019 ["Size of _CAPEOPEN_1_2_ICapeCustomDataSource"]
7020 [::std::mem::size_of::<_CAPEOPEN_1_2_ICapeCustomDataSource>() - 16usize];
7021 ["Alignment of _CAPEOPEN_1_2_ICapeCustomDataSource"]
7022 [::std::mem::align_of::<_CAPEOPEN_1_2_ICapeCustomDataSource>() - 8usize];
7023 ["Offset of field: _CAPEOPEN_1_2_ICapeCustomDataSource::me"]
7024 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapeCustomDataSource, me) - 0usize];
7025 ["Offset of field: _CAPEOPEN_1_2_ICapeCustomDataSource::vTbl"]
7026 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapeCustomDataSource, vTbl) - 8usize];
7027};
7028pub type CAPEOPEN_1_2_ICapeCustomDataSource = _CAPEOPEN_1_2_ICapeCustomDataSource;
7029#[repr(C)]
7030#[derive(Debug, Copy, Clone)]
7031pub struct CAPEOPEN_1_2_ICapeThermoPetroleumFractions_VTable {
7032 pub base: ICapeInterface_VTable,
7033 pub SetPetroCompoundProp: ::std::option::Option<
7034 unsafe extern "C" fn(
7035 me: *mut ::std::os::raw::c_void,
7036 propertyID: *mut ICapeString,
7037 basis: *mut ICapeString,
7038 values: *mut ICapeArrayReal,
7039 ) -> CapeResult,
7040 >,
7041 pub SetPetroBulkProp: ::std::option::Option<
7042 unsafe extern "C" fn(
7043 me: *mut ::std::os::raw::c_void,
7044 propertyID: *mut ICapeString,
7045 basis: *mut ICapeString,
7046 value: CapeReal,
7047 ) -> CapeResult,
7048 >,
7049 pub GetPetroCompoundProp: ::std::option::Option<
7050 unsafe extern "C" fn(
7051 me: *mut ::std::os::raw::c_void,
7052 propertyID: *mut ICapeString,
7053 basis: *mut ICapeString,
7054 values: *mut ICapeArrayReal,
7055 ) -> CapeResult,
7056 >,
7057 pub GetPetroBulkProp: ::std::option::Option<
7058 unsafe extern "C" fn(
7059 me: *mut ::std::os::raw::c_void,
7060 propertyID: *mut ICapeString,
7061 basis: *mut ICapeString,
7062 value: *mut CapeReal,
7063 ) -> CapeResult,
7064 >,
7065 pub PetroPropList: ::std::option::Option<
7066 unsafe extern "C" fn(
7067 me: *mut ::std::os::raw::c_void,
7068 propertyIDs: *mut ICapeArrayString,
7069 ) -> CapeResult,
7070 >,
7071 pub GetPetroPropAttribute: ::std::option::Option<
7072 unsafe extern "C" fn(
7073 me: *mut ::std::os::raw::c_void,
7074 propertyID: *mut ICapeString,
7075 attributeName: *mut ICapeString,
7076 attributeValue: *mut ICapeValue,
7077 ) -> CapeResult,
7078 >,
7079 pub CopyPetroProperties: ::std::option::Option<
7080 unsafe extern "C" fn(
7081 me: *mut ::std::os::raw::c_void,
7082 source: *mut _CAPEOPEN_1_2_ICapeThermoMaterial,
7083 ) -> CapeResult,
7084 >,
7085 pub UpdatePetroProperties:
7086 ::std::option::Option<unsafe extern "C" fn(me: *mut ::std::os::raw::c_void) -> CapeResult>,
7087}
7088#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7089const _: () = {
7090 ["Size of CAPEOPEN_1_2_ICapeThermoPetroleumFractions_VTable"]
7091 [::std::mem::size_of::<CAPEOPEN_1_2_ICapeThermoPetroleumFractions_VTable>() - 96usize];
7092 ["Alignment of CAPEOPEN_1_2_ICapeThermoPetroleumFractions_VTable"]
7093 [::std::mem::align_of::<CAPEOPEN_1_2_ICapeThermoPetroleumFractions_VTable>() - 8usize];
7094 ["Offset of field: CAPEOPEN_1_2_ICapeThermoPetroleumFractions_VTable::base"]
7095 [::std::mem::offset_of!(CAPEOPEN_1_2_ICapeThermoPetroleumFractions_VTable, base) - 0usize];
7096 ["Offset of field: CAPEOPEN_1_2_ICapeThermoPetroleumFractions_VTable::SetPetroCompoundProp"][::std::mem::offset_of!(
7097 CAPEOPEN_1_2_ICapeThermoPetroleumFractions_VTable,
7098 SetPetroCompoundProp
7099 )
7100 - 32usize];
7101 ["Offset of field: CAPEOPEN_1_2_ICapeThermoPetroleumFractions_VTable::SetPetroBulkProp"][::std::mem::offset_of!(
7102 CAPEOPEN_1_2_ICapeThermoPetroleumFractions_VTable,
7103 SetPetroBulkProp
7104 )
7105 - 40usize];
7106 ["Offset of field: CAPEOPEN_1_2_ICapeThermoPetroleumFractions_VTable::GetPetroCompoundProp"][::std::mem::offset_of!(
7107 CAPEOPEN_1_2_ICapeThermoPetroleumFractions_VTable,
7108 GetPetroCompoundProp
7109 )
7110 - 48usize];
7111 ["Offset of field: CAPEOPEN_1_2_ICapeThermoPetroleumFractions_VTable::GetPetroBulkProp"][::std::mem::offset_of!(
7112 CAPEOPEN_1_2_ICapeThermoPetroleumFractions_VTable,
7113 GetPetroBulkProp
7114 )
7115 - 56usize];
7116 ["Offset of field: CAPEOPEN_1_2_ICapeThermoPetroleumFractions_VTable::PetroPropList"][::std::mem::offset_of!(
7117 CAPEOPEN_1_2_ICapeThermoPetroleumFractions_VTable,
7118 PetroPropList
7119 )
7120 - 64usize];
7121 ["Offset of field: CAPEOPEN_1_2_ICapeThermoPetroleumFractions_VTable::GetPetroPropAttribute"][::std::mem::offset_of!(
7122 CAPEOPEN_1_2_ICapeThermoPetroleumFractions_VTable,
7123 GetPetroPropAttribute
7124 )
7125 - 72usize];
7126 ["Offset of field: CAPEOPEN_1_2_ICapeThermoPetroleumFractions_VTable::CopyPetroProperties"][::std::mem::offset_of!(
7127 CAPEOPEN_1_2_ICapeThermoPetroleumFractions_VTable,
7128 CopyPetroProperties
7129 )
7130 - 80usize];
7131 ["Offset of field: CAPEOPEN_1_2_ICapeThermoPetroleumFractions_VTable::UpdatePetroProperties"][::std::mem::offset_of!(
7132 CAPEOPEN_1_2_ICapeThermoPetroleumFractions_VTable,
7133 UpdatePetroProperties
7134 )
7135 - 88usize];
7136};
7137#[repr(C)]
7138#[derive(Debug, Copy, Clone)]
7139pub struct _CAPEOPEN_1_2_ICapeThermoPetroleumFractions {
7140 pub me: *mut ::std::os::raw::c_void,
7141 pub vTbl: *mut CAPEOPEN_1_2_ICapeThermoPetroleumFractions_VTable,
7142}
7143#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7144const _: () = {
7145 ["Size of _CAPEOPEN_1_2_ICapeThermoPetroleumFractions"]
7146 [::std::mem::size_of::<_CAPEOPEN_1_2_ICapeThermoPetroleumFractions>() - 16usize];
7147 ["Alignment of _CAPEOPEN_1_2_ICapeThermoPetroleumFractions"]
7148 [::std::mem::align_of::<_CAPEOPEN_1_2_ICapeThermoPetroleumFractions>() - 8usize];
7149 ["Offset of field: _CAPEOPEN_1_2_ICapeThermoPetroleumFractions::me"]
7150 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapeThermoPetroleumFractions, me) - 0usize];
7151 ["Offset of field: _CAPEOPEN_1_2_ICapeThermoPetroleumFractions::vTbl"]
7152 [::std::mem::offset_of!(_CAPEOPEN_1_2_ICapeThermoPetroleumFractions, vTbl) - 8usize];
7153};
7154pub type CAPEOPEN_1_2_ICapeThermoPetroleumFractions = _CAPEOPEN_1_2_ICapeThermoPetroleumFractions;
7155unsafe extern "C" {
7156 pub static libraryId_CAPEOPEN_1_2: CapeUUID;
7157}
7158unsafe extern "C" {
7159 pub static categoryId_CAPEOPEN_1_2_Component_1_2: CapeUUID;
7160}
7161unsafe extern "C" {
7162 pub static CAPEOPEN_1_2_ICapeIdentification_UUID: CapeUUID;
7163}
7164unsafe extern "C" {
7165 pub static CAPEOPEN_1_2_ICapeCollection_UUID: CapeUUID;
7166}
7167unsafe extern "C" {
7168 pub static CAPEOPEN_1_2_ICapeParameter_UUID: CapeUUID;
7169}
7170unsafe extern "C" {
7171 pub static CAPEOPEN_1_2_ICapeRealParameter_UUID: CapeUUID;
7172}
7173unsafe extern "C" {
7174 pub static CAPEOPEN_1_2_ICapeIntegerParameter_UUID: CapeUUID;
7175}
7176unsafe extern "C" {
7177 pub static CAPEOPEN_1_2_ICapeStringParameter_UUID: CapeUUID;
7178}
7179unsafe extern "C" {
7180 pub static CAPEOPEN_1_2_ICapeBooleanParameter_UUID: CapeUUID;
7181}
7182unsafe extern "C" {
7183 pub static CAPEOPEN_1_2_ICapeArrayParameter_UUID: CapeUUID;
7184}
7185unsafe extern "C" {
7186 pub static CAPEOPEN_1_2_ICapeArrayRealParameter_UUID: CapeUUID;
7187}
7188unsafe extern "C" {
7189 pub static CAPEOPEN_1_2_ICapeArrayIntegerParameter_UUID: CapeUUID;
7190}
7191unsafe extern "C" {
7192 pub static CAPEOPEN_1_2_ICapeArrayStringParameter_UUID: CapeUUID;
7193}
7194unsafe extern "C" {
7195 pub static CAPEOPEN_1_2_ICapeArrayBooleanParameter_UUID: CapeUUID;
7196}
7197unsafe extern "C" {
7198 pub static CAPEOPEN_1_2_ICapeParameterSpecification_UUID: CapeUUID;
7199}
7200unsafe extern "C" {
7201 pub static CAPEOPEN_1_2_ICapeRealParameterSpecification_UUID: CapeUUID;
7202}
7203unsafe extern "C" {
7204 pub static CAPEOPEN_1_2_ICapeIntegerParameterSpecification_UUID: CapeUUID;
7205}
7206unsafe extern "C" {
7207 pub static CAPEOPEN_1_2_ICapeStringParameterSpecification_UUID: CapeUUID;
7208}
7209unsafe extern "C" {
7210 pub static CAPEOPEN_1_2_ICapeBooleanParameterSpecification_UUID: CapeUUID;
7211}
7212unsafe extern "C" {
7213 pub static CAPEOPEN_1_2_ICapeArrayParameterSpecification_UUID: CapeUUID;
7214}
7215unsafe extern "C" {
7216 pub static CAPEOPEN_1_2_ICapeArrayRealParameterSpecification_UUID: CapeUUID;
7217}
7218unsafe extern "C" {
7219 pub static CAPEOPEN_1_2_ICapeArrayIntegerParameterSpecification_UUID: CapeUUID;
7220}
7221unsafe extern "C" {
7222 pub static CAPEOPEN_1_2_ICapeArrayStringParameterSpecification_UUID: CapeUUID;
7223}
7224unsafe extern "C" {
7225 pub static CAPEOPEN_1_2_ICapeArrayBooleanParameterSpecification_UUID: CapeUUID;
7226}
7227unsafe extern "C" {
7228 pub static CAPEOPEN_1_2_ICapeSimulationContext_UUID: CapeUUID;
7229}
7230unsafe extern "C" {
7231 pub static CAPEOPEN_1_2_ICapeUtilities_UUID: CapeUUID;
7232}
7233unsafe extern "C" {
7234 pub static CAPEOPEN_1_2_ICapeDiagnostic_UUID: CapeUUID;
7235}
7236unsafe extern "C" {
7237 pub static CAPEOPEN_1_2_ICapeMaterialManager_UUID: CapeUUID;
7238}
7239unsafe extern "C" {
7240 pub static CAPEOPEN_1_2_ICapeCOSEUtilities_UUID: CapeUUID;
7241}
7242unsafe extern "C" {
7243 pub static CAPEOPEN_1_2_ICapeThermoMaterial_UUID: CapeUUID;
7244}
7245unsafe extern "C" {
7246 pub static CAPEOPEN_1_2_ICapeThermoMaterialContext_UUID: CapeUUID;
7247}
7248unsafe extern "C" {
7249 pub static CAPEOPEN_1_2_ICapeThermoCompounds_UUID: CapeUUID;
7250}
7251unsafe extern "C" {
7252 pub static CAPEOPEN_1_2_ICapeThermoPhases_UUID: CapeUUID;
7253}
7254unsafe extern "C" {
7255 pub static CAPEOPEN_1_2_ICapeThermoPropertyRoutine_UUID: CapeUUID;
7256}
7257unsafe extern "C" {
7258 pub static CAPEOPEN_1_2_ICapeThermoEquilibriumRoutine_UUID: CapeUUID;
7259}
7260unsafe extern "C" {
7261 pub static CAPEOPEN_1_2_ICapeThermoUniversalConstant_UUID: CapeUUID;
7262}
7263unsafe extern "C" {
7264 pub static CAPEOPEN_1_2_ICapeThermoPropertyPackageManager_UUID: CapeUUID;
7265}
7266unsafe extern "C" {
7267 pub static CAPEOPEN_1_2_ICapeUnitPort_UUID: CapeUUID;
7268}
7269unsafe extern "C" {
7270 pub static CAPEOPEN_1_2_ICapeUnit_UUID: CapeUUID;
7271}
7272unsafe extern "C" {
7273 pub static CAPEOPEN_1_2_ICapePersistWriter_UUID: CapeUUID;
7274}
7275unsafe extern "C" {
7276 pub static CAPEOPEN_1_2_ICapePersistReader_UUID: CapeUUID;
7277}
7278unsafe extern "C" {
7279 pub static CAPEOPEN_1_2_ICapePersist_UUID: CapeUUID;
7280}
7281unsafe extern "C" {
7282 pub static CAPEOPEN_1_2_ICapeReport_UUID: CapeUUID;
7283}
7284unsafe extern "C" {
7285 pub static CAPEOPEN_1_2_ICapeFlowsheetMonitoringComponent_UUID: CapeUUID;
7286}
7287unsafe extern "C" {
7288 pub static CAPEOPEN_1_2_ICapeStream_UUID: CapeUUID;
7289}
7290unsafe extern "C" {
7291 pub static CAPEOPEN_1_2_ICapeFlowsheetMonitoringEventSink_UUID: CapeUUID;
7292}
7293unsafe extern "C" {
7294 pub static CAPEOPEN_1_2_ICapeFlowsheetMonitoring_UUID: CapeUUID;
7295}
7296unsafe extern "C" {
7297 pub static CAPEOPEN_1_2_ICapeThermoMaterialCustomData_UUID: CapeUUID;
7298}
7299unsafe extern "C" {
7300 pub static CAPEOPEN_1_2_ICapeCustomDataSource_UUID: CapeUUID;
7301}
7302unsafe extern "C" {
7303 pub static CAPEOPEN_1_2_ICapeThermoPetroleumFractions_UUID: CapeUUID;
7304}